# Sandbox for Proposed Challenges

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

Sandbox FAQ

## Posting

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

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

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

## Discussion

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

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

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

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

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

## Other

Search the sandbox / Browse your pending proposals

The sandbox works best if you sort posts by active.

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

Get the Sandbox Viewer to view the sandbox more easily!

## Array of Integers to Array of Digits

Given an array of arbitrary length containing only integers, output an array of integers of each digit of each integer in the array.

Notes

• The input array will only consist of integers in base 10

• The integers will be in the range of [0, MAX_INT] where MAX_INT is the greatest value an integer can have in your language

• Assume that all integers will be positive, however you can interpret the integers as signed or unsigned

• String manipulation and the use of any regex is banned by default

• The outputted array must be exactly 1 deep and contain only integers

• The order of the digits in the outputted array must be exactly as they were in the inputted array

• Leading zeros are to be stripped, as they should be when parsed as an integer

Examples

[2, 3, 5, 7, 11, 13] -> [2, 3, 5, 7, 1, 1, 1, 3]
[1, 2, 3, 4, 5] -> [1, 2, 3, 4, 5]
[123, 456, 789, 101112] -> [1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 0, 1, 1, 1, 2]
[0, 000, 000123] -> [0, 0, 1, 2, 3] //'000' is treated as '0' and '000123' is treated as '123'

• Seems pretty straightforward, but pretty trivial in most languages. (Trivial does not mean off topic, but you will likely get lots of answers, as well as some downvotes). You should specify that the integers are in base 10. May 25 '16 at 14:19
• Will the input array contain 0 or negative integers? May 25 '16 at 19:30
• You say integers, but I take it you mean positive integers?
– xnor
May 25 '16 at 22:19
• I updated the specification May 26 '16 at 12:22
• You should clarify that leading zeros are stripped, so that people don't need to infer that from the last test case. May 26 '16 at 18:51
• What leading zeroes? Numbers can't have them if they are not strings. Is it an array of numbers or array of strings? May 29 '16 at 23:12
• It may be interesting to ban the use of string manipulation. This would change the challenge a lot, but it will force the answers to be less trivial. (also note that such a challenge may be frowned upon: meta.codegolf.stackexchange.com/a/8079/31203) Jun 1 '16 at 15:19
• You mention signed integers, but none of your examples contain negative numbers. Do we only need to support non-negative numbers? If not you should specify how negative numbers should be handled and add an example to the test cases. Jun 3 '16 at 11:33
• Personally, I doubt that string manipulation is the easiest way to do this in most languages? I don't think banning it improves the question. It just seems to make a bunch of languages unusuable, and the rest just entirely ignore it? Jun 9 '16 at 20:08

# Ping Pong

## The Challenge

This challenge is to make a program that prints a text ping-pong animation. Your program is to display a string of tildes with a PING on it moving to the right. Each tick, the text PING moves one to the right one character, reducing the number of tildes on the right by one and increasing the amount on the left by one. Once the PING reaches the right side of the string, it changes to a PONG and the reverse happens (i.e it moves to the left instead).

## Rules

• The number of tildes must always be the same
• The number of tildes must be at least 30
• The number of milliseconds between ticks must be at least 10 ms and at most 1 s
• The PING must start at the left hand of the string

## Scoring

Your score is the number of bytes plus/minus the following (all that apply):

• -10 bytes for browser implementation using the ping after the hash
• +10 bytes if your implementation does not clear previously outputted frames
• More suggestions welcome

Lowest score wins.

## Example Implementation (JS, Ungolfed)

i=0;b=false;len=50;td=40;function urlPong(){location.hash=new Array(i+1).join("~")+(!b?"PING":"PONG")+new Array(len-4-i+1).join("~");if(!b){if(len-4-i<=0){b=true;}else{i++;}}else{if(i<=0){b=false;}else{i--;};}setTimeout(urlPong,td);}urlPong();

• Why do you restrict this to be in a browser? That seems to add an unnecessary limitation on which languages can reasonably participate. Jun 9 '16 at 13:06
• Okay, I made it less browser dependant Jun 10 '16 at 0:57

# Implement this cipher

(I'm not sure what to call this cipher)

## Goal

Use the algorithm (explained in the Algorithm section) to implement a certain cipher.

The program must read input from STDIN or the closest available equivalent, use the algorithm to generate the ciphertext and a key.

The ciphertext and the key will be written to STDOUT or the closest available equivalent, preferably with the format (ciphertext)\n(key).

## Algorithm

Convert the characters in the string into the respective ASCII values. For example:

Hello -> 72 101 108 108 111

Next, you will need to generate a key as long as the string with random numbers in the range of 0-9.

Hello -> 62841

Add the integers in the random number sequence to the ASCII values of the string. In the above examples, 72 would become 78, and 101 would become 104.

72 + 6 = 78, 101 + 2 = 104, 108 + 8 = 116, etc

Next, convert the new ASCII values back to characters. In the above examples, the text Hello has become Nhttp.

## Examples

(These are simply examples of what the output might look like. The output can and will vary.)

Hello, World!

Hgqqu/$\\p{ni$
0255634519253


This will be encoded

Zhjs$~koo gj$iuhofgj
60104723305544750226


## Rules

• Submissions must be full programs.
• Languages newer than the challenge are allowed.
• Submissions will be scored in bytes.
• Standard loopholes are forbidden.
• This is code-golf, so the shortest code wins.

I'm sure this challenge needs a little tidying up and making it look and sound a bit nicer. I'm not very good at writing challenges, so I'd like some advice.

• This is an actual cipher (though not usually with ASCII codes). I don't remember the name right now. But seeing that, it might be a dupe. Jun 12 '16 at 15:13
• @EᴀsᴛᴇʀʟʏIʀᴋ Oh, I didn't know that. I thought it was original.
– m654
Jun 12 '16 at 15:32
• Yeah, it's called something like a key cipher. Jun 12 '16 at 15:34
• @EᴀsᴛᴇʀʟʏIʀᴋ What do you think of this challenge? Do you have any advice for making it... better?
– m654
Jun 12 '16 at 16:16
• If properly implemented (i.e. with a pre-shared key which covers the full range of symbols rather than just 0-9) this would be a one-time pad, which is (in some sense) the limit case of the Vigenère cipher. It's not quite a dupe of the Caesar cipher question, but it's barely more complicated. Jun 12 '16 at 21:57
• @PeterTaylor The Caesar cipher shifts the characters up the alphabet, but this one shifts the up the whole character range.
– m654
Jun 13 '16 at 7:49
• How does this handle overflow? It's easy to imagine a scenario where z (122) gets a number >=5 added to it. Jun 14 '16 at 15:03
• @TimmyD I hadn't thought about that... Maybe it could display an \x code? That's what my Python implementation does, but I'm not sure if that will work in some other languages.
– m654
Jun 14 '16 at 15:07

# Latin vs Greek vs Cyrillic / Battle of the Alphabets

Meta: This is just a rough draft, the challenge is still under development, feel free to add suggestions as comments or via chat pinging @flawr

Points that are unclear so far:

• Is there one fixed typeface for all three?
• Will the image always be provided in the exact horizontal orientation?
• How long will the provided text be, just single words? A single line? A multiline piece of text?

These three alphabets are relatively similar and even have some letters in common, but also a lot of distinct letters. In this challenge, you have to write a classifier that can distinguish these three alphabets, when presented with a raster image of a corresponding text.

This is an image from Wikipedia that shows the differences in the capital letters:

This challenge was inspired by this message.

• What about ambiguity? Expected output for POTATO, COMA, or TAXONOMY? Jun 15 '16 at 14:03
• Good point, then all outputs are correct. But I had longer pieces of texts in mind, like multiple lines, but now I'm thinking perhaps just single words would be easier. What would you say? Jun 15 '16 at 15:39
• I'd prefer the input to be a single letter, and the correct output to list all alphabets where it belongs, with score being number of correctly classified letters in a test battery (secondary goal is byte count). That may be vulnerable to hashing tricks though. Maybe the letters could also be randomly scaled to, say, 90% to 110%? Jun 16 '16 at 7:53
• @Zgarb it's still easy to get 100% with computer vision classifiers if there is only one nicely cropped letter as input and all test images have the same exact font as the one used in training Jun 17 '16 at 8:09
• I agree, thats why I'd use at least full words or lines. Jun 17 '16 at 8:36

# Don't let those functions get away

## Introduction

My imaginary language, PremOpt discourages the use of functions. They are the source of every performance problem. Your task today is to fix beginner PremOpt programmer's code.

Every statement's and loop's (if, switch, while, for) content is enclosed in brackets:

<if/switch/while/for> <statement here> {
<stuff>
}


Switch cases are one liners:

switch <value> {
case <val1>: <statement1>;
case <val2>: <statement2>;
case <val2>: <statement2>;
}


Functions look like these:

function <name>(arg1, arg2, arg3) {
// Stuff here
}

// Calling a function:
<name>(arg1, arg2, arg3);


Other lines end with a semi-colon.

Variables don't need to be declared, they're already initialized to null, you can set a variable to a value with

variableName = value;


Outputting a value is done by doing

out-><value>


## Input

Your input is a string with a piece of code. Each row is separated with a line-feed. The input may or may not contain functions.

## Output

You need to remove the functions from the code, and put their content to the where they were called.

Examples:

function hello() {
sayHello1();
sayHello2();
}
hello();


becomes

sayHello1();
sayHello2();


Multiple function calls:

function func() {
doStuff1();
doStuff2();
}
func();
func();


becomes

doStuff1();
doStuff2();
doStuff1();
doStuff2();


If the function takes in arguments:

function argFunc(arg1, arg2) {
doStuffWithArg(arg1);
doStuffWithArg2(arg2);
}
argFunc(myVar1, myVar2);
argFunc(myVar3, myVar4);


then you need to change the arguments inside the function to match with the calling arguments

doStuffWithArg(myVar1);
doStuffWithArg2(myVar2);
doStuffWithArg(myVar3);
doStuffWithArg2(myVar4);


## Test cases

fibonacci sequence:

a = 1;
b = 1;
function getNextNumber(num1, num2) {
return num1 + num2;
}

while(true) {
a = getNextNumber(a, b);
out->a;
b = getNextNumber(a, b);
out->b;
}


Should become

a = 1;
b = 1;

while(true) {
a = a + b;
out->a;
b = a + b;
out->b;
}


FizzBuzz:

for (counter = 0; counter <= 100; counter++) {
checkNumber(counter);
}

function checkNumber(num) {
if (num % 3 == 0  num % 5 == 0) {
out->"Fizz Buzz";
} else if (num % 3 == 0) {
out->"Fizz"
} else if (num % 5 == 0) {
out->"Buzz"
} else {
out->num;
}
out->newLine;
}


Becomes:

for (counter = 0; counter <= 100; counter++) {
if (counter % 3 == 0  counter % 5 == 0) {
out->"Fizz Buzz";
} else if (counter % 3 == 0) {
out->"Fizz"
} else if (counter % 5 == 0) {
out->"Buzz"
} else {
out->counter;
}
out->newLine;
}


## Rules

• There'll be no recursive functions in the input
• Standard loopholes are forbidden
• This grammar doesn't seem to be well defined enough for this to not be too broad. What about functions in functions? What kinds of literals are expected to be supported? Can functions have the same name but different arguments? What operators have to be supported (specifically w.r.t. functions, like myFun(++foo)++)? What about functions that return things but have more than one operations, but are in a heavily nested statement? This is all just from the top of my head, there are likely more such problems. I think you would need to heavily simplify the language for this to be a good question. Jun 28 '16 at 12:58

# fix show

Your task is given n, you must print first n character returned from Haskell expression fix show.

Let me explain how fix show produces the "magic" string.

show is just escaping the string and then add quote. Since the resulting string consists only double quotes and backslash, show then essentially just put backslash before every character then quote the resulting string.

show str = '"' : concat ( zipWith (\x y->[x,y]) (repeat '\\') str ) ++ "\"" -- Well, this is not what prelude give, but


fix is, well, fixpoint combinator. But thanks for laziness, it won't do a infinite loop first.

The string is equivalent to the string defined below:

Assuming there is a series of string. The first string is "" and the next series is just application of show to previous string:

"" "\"\"" "\"\\"\\"\"" "\"\\"\\\\"\\\\"\\"\"" "\"\\"\\\\"\\\\\\\\"\\\\\\\\"\\\\"\\"\""

For all n, there is k so that for all l above k, n-th character of l-th string from series is same. That character is the n-th character of fix show

TODO: I hate the sentence above, please fix it.

The first 100 character in resulting string

"\"\\\"\\\\\\\"\\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\


So, another implementation is

fixshow = '"' : zip (repeat '\') fixshow ++ "\""


## Rules

1. You are not allowed to use function fix, show, and the equivalent functions.
2. Shortest answer wins.

## Sandbox question

Is there another way to prevent answer like flip take$fix show, or without importing f k=k$f k;j n=take n$f show. And how about array programming language like APL, J and Jelly? • Your construction doesn't work because zip doesn't intersperse the characters, but creates a list of tuples. I think the backslashes also need escaping. It would be helpful to explain that the number of backslashes in sequence goes 1,3,7,15,... with numbers one less than powers of two. It would be a shame to eliminate all languages with lazy evaluation or generators. It's also vague. Python has generators but they are totally useless here. Even Haskell needs a costly import to get fix. – xnor Jun 1 '16 at 3:52 • The output should start "\"\\\"\\\\\\\"\\\\\\\\\\\\\\\". – xnor Jun 1 '16 at 3:58 • Language-specific questions are not likely to make much challenge acceptors. Jun 3 '16 at 7:25 • @EʀɪᴋᴛʜᴇGᴏʟғᴇʀ This question isn't language specific, it just involves implementing a particular Haskell program in any other language. That said, it was a bit hard to figure out what was going on as someone who doesn't really know Haskell. Jun 3 '16 at 13:18 • @FryAmTheEggman This should be closed as "unclear what you're asking". Jun 3 '16 at 13:55 • seems like a cool challenge, but instead of trying to explain lazy evaluation, just define show rigorously, and then say the challenge is to output the limit of applying show n times on the empty string. also, your output is wrong. Jun 3 '16 at 18:46 • @proudhaskeller when you say the limit of applying show n times, do you mean result of applying show infinite times on ""? Jun 4 '16 at 15:21 • @xnor 1. I just hate the answer flip take$fix show. How do I avoid it? 2. Fixed. Jun 4 '16 at 15:24
• @ChristianIrwan no, because there is no such thing, applying infinite times. instead, if you have a series of strings, first the empty string, then applying once, then twice, and so on, and at each string look at the ith character, from some point on it will be identical in all the strings of the series, and the ith character of the limit will be this character. Jun 4 '16 at 15:29
• @proudhaskeller Oh, I see. Thanks. Jun 4 '16 at 16:04
• The implementation with zipWith. Maybe you could just ban the command show and equivalents? I think implementing it and a a pseudo-fix would be interesting and not definitely better than concatenating powers-of-2-sized blocks.
– xnor
Jun 5 '16 at 2:54
• *The implementation with zipWith doesn't work.
– xnor
Jun 5 '16 at 21:58

## Golfing with ultrasound

Within medical physics, the percentage of ultrasound reflected between material boundaries can be calculated using two pieces of data: the density(p) and the speed(c) at which sound travels through the material.

To calculated the percentage reflection the following equation can be used

(Z1-Z2)^2 / (Z1+Z2)^2

Where Z1 and Z2 are the acoustic impedances(Z) of the two materials. Z is calculated such that Z=pc That is density * speed of sound in the material

## This is where the issue lies

I have two ways of asking the question

## 1:

Given the acoustic impedance for two materials, calculate the percentage reflection.

## 2:

Given the density and speed of sound in two materials, calculate the percentage reflection

## Reason

The first method will be much simpler, in the way you are just plugging values into a formula. However I feel that method 2 is heavy on the inputs, and I understand that four inputs is a large number of inputs in golfing challenges

On posting the question I will also add a number of test cases

• Firstly, I think you should add test cases while it's still in the sandbox. I find it's easy to miss important ones. In your formula you say Z=pc. What is c? I think you should add some formatting to your formulas, as they are a bit hard to read. You could also consider using some TeX service to generate an image of the formula for you. Also, density is usually denoted by ρ. Jun 29 '16 at 19:38
• I was going to use rho, but I didn't know where to find one. In hind sight I could have copied and pasted from Wikipedia. Speed should have been given as c not v. But I will make clear what I mean by Z=pc. What is TeX? I've not heard of it before? Jun 29 '16 at 19:41
• TeX is a very popular typesetting program, most of your textbooks were probably made using some variant of it. For example, go to this site and enter \frac{(Z_1-Z_2)^2}{(Z_1+Z_2)^2} as the text. You should see a much easier to read version of your formula as an image. Jun 29 '16 at 19:45
• @FryAmTheEggman Wow that's a really cool website, thanks! I will edit the question soon and hopefully it will be better Jun 29 '16 at 19:50
• With either option, it looks like there's a direct mathematical formula that leaves little to golf.
– xnor
Jun 29 '16 at 22:45

# Write a BF to Hexagony Converter!

According to community moderator Martin Ender ♦:

Hexagony is Turing-complete as any brainfuck program can be translated to Hexagony with some effort. (Source)

Your program's job is simple: take a valid brainfuck program, and convert it to an equivalent Hexagony program. For completeness, here are all the relavant commands in both BrainFuck and Hexaongy (taken from esolangs.org).

### brainfuck

brainfuck operates on an array of memory cells, also referred to as the tape, each initially set to zero. There is a pointer, initially pointing to the first memory cell. The commands are:

• > Move the pointer to the right
• < Move the pointer to the left
• + Increment the memory cell under the pointer
• - Decrement the memory cell under the pointer
• . Output the character signified by the cell at the pointer
• , Input a character and store it in the cell at the pointer (-1 for EOF)
• [ Jump past the matching ] if the cell under the pointer is less than or equal to 0
• ] Jump back to the matching [ if the cell under the pointer is nonzero

All characters other than ><+-.,[] should be considered comments and ignored.

### Modifications:

• Infinite tape in both directions
• Arbitrary precision integers (like hexagony)
• No overflow/underflow
• [ acts the same for negative numbers as it does for 0

### Source code

The source code consists of printable ASCII characters and line feeds and is interpreted as a pointy-topped hexagonal grid, where each cell holds a single-character command.

Because of this restriction, the number of commands in the source code will always be a centered hexagonal number. For reference, the first 10 centered hexagonal numbers are:

1, 7, 19, 37, 61, 91, 127, 169, 217, 271

When reading a source file, Hexagony first strips all whitespace characters. Then the remaining source code is padded to the next centered hexagonal number with no-ops and rearranged it into a regular hexagon. This means that the spaces in the examples above were only inserted for cosmetic reasons but don't have to be included in the source code. The following three programs are identical:

   a b c
d e f g
h . . . .
. . . .
. . .

abcdefgh...........

abcdefgh


But note that

abcdefg

would instead be the short form of

   a b
c d e
f g


### Control flow

Hexagony has 6 instruction pointers (IPs). They start out in the corners of the source code, pointing along the edge in the clockwise direction. Only one IP is active at any given time, initially the one in the top left corner (moving to the right). There are commands which let you switch to another IP, in which case the current IP will make another move (but not execute the next command), and then the new IP will start by executing its current command before making its first move. Each IP has an index from 0 to 5:

   0 . 1
. . . .
5 . . . 2
. . . .
4 . 3


The direction of an IP can be changed via several commands which resemble mirrors and branches.

The edges of the hexagon wrap around to the opposite edge. In all of the following grids, if an IP starts out on the a moving towards the b, the letters will be executed in order before returning to a:

   . . . .          . a . .          . . k .          . g . .
a b c d e        . . b . .        . . j . .        . h . . a
. . . . . .      g . . c . .      . . i . . e      . i . . b .
. . . . . . .    . h . . d . .    . . h . . d .    . j . . c . .
f g h i j k      . i . . e .      . g . . c .      k . . d . .
. . . . .        . j . . f        f . . b .        . . e . .
. . . .          . k . .          . . a .          . f . .


If the IP leaves the grid through corner in the direction of the corner there are two possibilities:

-> . . . .
. . . . .
. . . . . .
. . . . . . . ->
. . . . . .
. . . . .
-> . . . .


If the current memory cell (see below) is positive, the IP will continue on the bottom row. If it's zero or negative, the IP will continue on the top row. For the other 5 corners, just rotate the picture. Note that if the IP leaves the grid in a corner but doesn't point at a corner, the wrapping happens normally. This means that there are two paths that lead to each corner:

      . . . . ->
. . . . .
. . . . . .
-> . . . . . . .
. . . . . .
. . . . .
. . . . ->


### Special characters

. is a no-op: the IP will simply pass through.
@ terminates the program.

### Arithmetic

) increments the current memory edge.
( decrements the current memory edge.

### I/O

, reads a single byte from STDIN and sets the current memory edge to its value, or -1 if EOF is reached.
; takes the current memory edge modulo 256 (positive) and writes the corresponding byte to STDOUT.

## Control flow

$ is a jump. When executed, the IP completely ignores the next command in its current direction. This is like Befunge's #. _, |, /, \ are mirrors. They reflect the IP in the direction you'd expect. For completeness, the following table shows how they deflect an incoming IP. The top row corresponds to the current direction of the IP, the left column to the mirror, and the table cell shows the outgoing direction of the IP:  cmd │ E SE SW W NW NE ──────┼──────────────────── / │ NW W SW SE E NE \ │ SW SE E NE NW W _ │ E NE NW W SW SE | │ W SW SE E NE NW  < and > act as either mirrors or branches, depending on the incoming direction. The cells indicated as ?? are where they act as branches. In these cases, if the current memory edge is positive, the IP takes a 60° right turn (e.g. < turns E into SE). If the current memory edge is zero or negative, the IP takes a 60° left turn (e.g. < turns E into NE).  cmd │ E SE SW W NW NE ──────┼──────────────────── < │ ?? NW W E W SW > │ W E NE ?? SE E  [ switches to the previous IP (wrapping around from 0 to 5). ] switches to the next IP (wrapping around from 5 to 0). # takes the current memory edge modulo 6 and switches to the IP with that index. ### Memory manipulation { moves the MP to the left neighbour. } moves the MP to the right neighbour. " moves the MP backwards and to the left. This is equivalent to =}=. ' moves the MP backwards and to the right. This is equivalent to ={=. = reverses the direction of the MP. (This doesn't affect the current memory edge, but changes which edges are considered the left and right neighbour.) Some commands/description omitted for conciseness, full list here. ## Other rules: • Input/Output may be done however is most natural for your language • Output does not have to be formatted like a hexagon • Must run in a reasonable amount of time • Minimal brute-force • No brute-forcing the entire program • You can only use Hexagony commands specified in this challenge. • This is , so shortest code wins • {META NOTE: I know this challenge is hard, is there a better way to score?} • As usual, standard loopholes are prohibited. ## Test Cases: Input: (cat) ,.[,.] Output: (example) \ . . < _ . . . _ ; . . . . > , . @ . Input: ("123") +++++++++++++++++++++++++++++++++++++++++++++++++.+.+. Output: (example) ) ) ) ) ) ) ) ; ) ; / ) ) ) ) ) ) / ) ) ) ) ) ) ) / ) ) ) ) ) ) ) ) / ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) . . @ ; < Input: (@primo's infinite Fibonacci) +[[<+>->+>+<<]>] Output: (example) ) \ . . . . | . | . / { } < . . . . . > [ . / > . . . . . . . . . . . . . . . . @ . . . . / . ] < . > < . ] . . . _ > " ' / | . > < . . . . _ / . . . / . . [ . . . . / . . . . . . ) . . . . . . . . . . ] . . . . [ . . . . | . . [ . . . . ( . \ ) ] ) ] <  • I am quite sure that the outputs are not unique, are they? Jul 4 '16 at 16:18 • @flawr The outputs do not have to be unique as long as the inputted BF programs do the exact same thing, under all circumstances. – Blue Jul 4 '16 at 16:22 • I think Hexagony's padding rules would be important, especially if you don't require the output to be formatted like a hexagon. I predict most answers to generate tons of no-ops at the end, which can't be omitted without messing up the layout. Jul 4 '16 at 16:26 • I don't think it's a good idea to mask brainfuck in the question body, since it hurts searchability. You're going to need the brainfuck tag anyway. Jul 4 '16 at 16:36 • @Dennis Should I change the title as well? – Blue Jul 4 '16 at 16:48 • No, the title cannot contain fuck due to network-wide rules. Jul 4 '16 at 16:51 • I think this challenge is actually rather easy except for translating [] loops: everything else is a simple mapping. I think the most likely type of answer will just generate the code mostly linearly while keeping track of a "stack" of loops and then figuring out what size hexagon to put it in. Jul 4 '16 at 18:34 • @FryAmTheEggman Should I make this challenge metagolf to encourage less linear output? – Blue Jul 4 '16 at 20:29 • @Blue That would certainly be interesting, but I have doubts you'd get a lot of participation in that case. Jul 4 '16 at 20:41 • I agree with Martin, I may not have worded my last comment very well, as the [] translations will actually be rather time consuming, if not difficult. Further increasing the complexity of the challenge will make it more interesting, but it might be too much to expect more than an answer or two at that point. Jul 4 '16 at 21:11 ## Platformer game Write a platformer game. Rules: • Keyboard input, minimum three commands: left, right and jump; • Real-time. Screen should update (and the game iterate) on timer. Update speed should not depend on CPU speed. FPS should be between 2 and 120; • It should be possible both to win and to lose (the game can although be very hard and require preparing a special bot to win or to lose); • Playing field should have at lest 64 positions, minimum width is 6, minimum height is 5. • Player may move left, right or jump. Player moves down automatically unless on a platform. Jumping means moving up for some limited time (not higher than 67% of playing field's height), then falling down like usual. • Falling down outside playing field is losing the game. Stepping on 6 distinct platforms is a win. • Player, platforms and borders of area should be visible on playing field. If output method is ASCII art, it may looks like this: .....----... ............ ...@....---- ..---....... .......---.. ............  • Platforms may be horizontal, vertical, diagonal. Platforms should not overlap (except of differently oriented). Platform's projection to horizontal and vertical axes should not overlap for at least 4 platforms. Example of too projection-overlapping playing field: ............ ....@....... .--.--..--.. ............ .--.--..--.. ............  • Platforms may move. Overlapping rules apply only to initial positions. • The game should track losing and winning conditions and stop the game, outputting distinct messages in case of lose or win. • I feel like this spec is much too broad. Different answers will vary so much that I don't think they will be comparable. I think you need to specify each interaction precisely. Jul 4 '16 at 19:43 • @FryAmTheEggman, The idea was to just implement a platformer game, with rules only to prevent "degenerate", uninteresting cases (like 1x1 field with 0 platforms and unconditional lose in the first turn). Do you think it would be more interesting if each answer's game would basically be the same? – Vi. Jul 4 '16 at 21:06 • I think it is a much more interesting golfing problem if all the games are the same, as otherwise what is the point of golfing? I don't think this is a good site to try to get interesting platforming games, as I don't think this will work with either a pop-con or code-challenge either. Jul 4 '16 at 21:09 • I though it would be interesting if main point were to design the game to be compactly implementable, not just to implement already designed game in a compact way... – Vi. Jul 4 '16 at 21:22 # Compute h-index of PPCG users Thanks to @Suever for his help refining this challenge. ## Background The h-index is a commonly used metric that measures the amount and quality of publications of a given scholar or researcher. It is defined as follows: A scholar with an h-index of n has published n papers each of which has been cited at least n times. ## Adaptation for PPCG In this challenge I propose to compute the h-index of PPCG users based on the analogy • paperanswer; • paper's citations → answer's vote count, defined as upvotes minus downvotes. The following examples illustrate the computation of h-index. The array to the left is the vote count of answers in descending order for a hypothetical user, and the number to the right is the resulting h-index: [5 3 2 1 1] 2 [1 1 1] 1 [] 0 [-1 -2] 0 [0] 0 [9 4 3 ...] 3  Referring to the last example, note that we don't need to know the array entries after the 3. ## The challenge Given a user identification, output their h-index. ## Rules User identification can be defined as anything reasonable, such as user number, user name, or user name without spaces. The result must be based on actual data from the PPCG site. You may want to take a look at the StackExchange API, for example here. Note that some users have a lot of answers. For one such user the API may not give all the results, or may only give them split across several chunks. However, if you ask the API to provide the results with an appropriate sorting you may not need all of them to compute the h-index (see last example above). Also, you may assume that the h-index of any user will be less than 100. If the answer can't be tested in an online compiler (for example due to restrictions to read web content), you are encouraged (although not required) to post some evidence that the answer works, such as a screen capture. This is code golf. Fewest bytes wins. ## Table of h-indices After submitting your answer, you may optionally edit the table below to include your own h-index, in the indicated format. Please keep the table in decreasing order, so that users with higher h-indices appear higher on the table. I will remove the dummy user names when the table has some actual content. Example user name: 5 Another example: 3 Yet another user: 3  • @FryAmTheEggman Having 1000 answers is irrelevant only if you ask the API for the answers in descending order of votes. The note is intended to make it clear that asking for the answers in that order is probably a good idea. I've rephrased a little, I hope it's clearer now. As for how many results the API provides in the same chunk, I think the limit is 100, but I'm not sure Jul 4 '16 at 23:45 • Yes, I think that is much clearer now. Also, Yet another user? I hate that guy... Jul 5 '16 at 0:13 • We've had a challenge to find the h index. With that done, this mostly looks like a question to query the SE API. – xnor Jul 5 '16 at 10:28 • @xnor Oh. Pity. I didn't see that challenge. I guess this is mostly a duplicate then Jul 5 '16 at 11:11 # What is closer? Tags: , Inputs: a, b (Both integer and positive) .Output: Integer, in natural numbers sequence. We have one single atom which has a electrons, we ionize the atom with b positive charges (take b electrons out). The output is the sum of the orbital quantum numbers (n,l,ml) which is nearest to the atom shell. EXAMPLE: We take 3 electrons from 26Fe, Now we have 26Fe3+. We need to get the sum of the nearest remained orbitals quantum numbers to the shell. We have this configuration for Fe3+: [Ar], 3d3, 4s2 The nearest orbital to shell has these numbers: n = 4 l = 0 ml = 0  In this case: a => 26 b => 3 output => 4  My 3rd grade chemistry teacher asked me once to create such a program, but I didn't success, I found the paper that my teacher wrote these descriptions on it and I typed it here because I believe that someone might create an interesting code-golf for this. • You can't create the atoms and electrons tags right now (2/150 rep). Even then, we're not going to need them. Jul 6 '16 at 9:03 • This is a long way from being self-contained. I don't know whether someone who knows quantum chemistry would find the question clear, but I need a link to some background material to even start trying to work out what I'm supposed to do. Jul 6 '16 at 16:59 # KotH Chess Warriors. This game will be based on fairy chess, but really could be imagined to be anything else. Submissions will include both: A function that determines the moves of the piece (as in, how the piece can move), called at the start, and a function that determines how it moves each turn, called each turn, of course. Bot's move simultaneously; strategy is needed. A piece may make 5 moves in a row before it must rest. Bot's will be able to do any valid move they choose, and the input they will get when deciding what to do will be: a value that can be 2, 1, 0, or -1, for each possible move. 2 denotes that an ally is in that square, 1 denotes that an enemy is in that space. 0 denotes an empty space which could be moved to, -1 represents an illegal move, which may result from the board ending or another piece in the way. If a piece attempts to move into it's ally, the following things could happen; A) ally stays still; Piece stays where it is. B) ally moves; Piece moves where it wishes. C) ally is captured; Piece recaptures See below for early stage point spending system ## Sandbox I don't have the experience to host this challenge, so someone who can program these kind of things will need to help. I have sketched out some movement point system, but I need to figure out how large the board is, and so how valuable riders (pieces that move continously, like a rook), would be, compared to leapers, before i could finalise it Here is the quick system done, which could clearly be improved (for one thing, the multiple move thing probably needs to be a bit more expensive): ### Point buying system Points: each piece receives (to be decided) points base move: points spent on a move are as so. Largest dimension + floor(small dimension/2). There are no riders in this mode; Only repeated movement Repeated movement by x cost:*ceil(x^1.25) make move-only=/2 It is possible to have a leaping attack and sliding attack on the same square; it is also possible to have only one of these able to attack; How this is sorted is that both moves get their own value, and so you can attack if the attack move by itself can reach there. Examples for base move costs: • Any king move: 1 • any knight move: 2 • Zebra move:4 • Camel move:3 PLEASE NOTE: These move values on their own are not representative of how powerful a piece with that move actually is; A knight is better than a camel or zebra. However, when paired with other moves, the zebra and camel moves may become effective. Example of moves that can be purchased:  1 7 2 3 6 @55555 4  • move 1=(2+floor(0/2)):2 points • move 2=(1+floor(1/2)):1 point • move 3=(2+floor(1/2)):2 points • move 4=(1+floor(0/2)): 1 point • move 5=((1+floor(0/2))*ceil(5^1.25))=8 points • move 6=(5+floor(0/2))=5 points • move 7=(5+floor(1/2))=5 points in total, this piece costs: (2+2+1+1+8+5+5) 24 points. Considerations: • How large the board is. I'm fairly sure of having a cylindrical board; the left wraps to the right and vice versa. • how exactly turns work. So far, I have thought that the way it works is this: Everyone moves simultaneously. When you move, you deplete your remaining moves, which tops and starts at 5. You can choose to not move, and replenish your moves at any point. However, this could induce stale games which don't end properly. • I think you should add a hyperlink to the Wikipedia page on Fairy Chess for users to refer to. Also, if you're interested, there's a great game online that involves unique fairy chess pieces. It's called Chess Evolved Online. Not only are there different pieces, but you build your setup ahead of time and don't know what setup your opponent will have. Jul 22 '16 at 19:34 ## Calculate my total hours I record the work I do for one of my customers using a flat file in the following format: 0000-00-00 0000-0000 0.0 code0000 free text  The 0.0 represents the amount of time spent on the task identified by code0000, where 0000 is an optional numeric task ID and code is a project code (and does not contain digits or spaces). Because I'm lazy, I need as short a program as possible to calculate subtotals of my total time for each project, plus a grand total. If you are using plain text output it should show the hours first and then the project code on the same line, and then the grand total on a line on its own with no code. You don't need to use a specific numeric format but you should be capable of dealing with half hours (0.5) in both the input and output. • Are the beginning strings (presumably a date, and something else?) and the free text ever relevant? If not, I'd consider omitting them. Is any order for the subtotals acceptable? Jul 11 '16 at 14:35 • @FryAmTheEggman Sorry, but that's my actual input format. The good news is that the subtotals can be in any order. – Neil Jul 11 '16 at 16:26 • It's obviously up to you, but I think that input makes it a chameleon challenge. I wrote a preliminary Pyth answer to do this, and only 16 of the 36 bytes were related to summing and grouping, the other 20 were used for processing. (Surely it can't be that hard to preprocess away the first two fields and the free text? :P ) Jul 11 '16 at 17:07 • If I didn't have to preprocess them away I could just open the file in Excel and be done with it... – Neil Jul 11 '16 at 18:41 # Undone Mathematics ## Definitions I define the following: nᵗʰ Undone Addition of A Let +ᵣ A denotes the nᵗʰ Redacted Addition of A; the sum of the elements of A after n layers have been removed in every dimension:  ²+ᵣ [1,2,3,4,5,6,7] = ∑ [3,4,5] = 12 // 1D: remove leading and trailing elements [[1,1,3] ¹+ᵣ [4,2,5] = ∑ [2] = 2 // 2D: remove leading and trailing rows and columns [3,4,1]]  Then +ᵤ A denotes the nᵗʰ Undone Addition of A; the nᵗʰ Redacted Addition of A plus the sum of the elements of A:  ²+ᵤ [1,2,3,4,5,6,7] = ²+ᵣ [1,2,3,4,5,6,7] + ∑ [1,2,3,4,5,6,7] [[1,1,3] [[1,1,3] [[1,1,3] ¹+ᵤ [4,2,5] = ¹+ᵣ [4,2,5] + ∑ [4,2,5] [3,4,1]] [3,4,1]] [3,4,1]]  nᵗʰ Undone Multiplication of A Let ×ᵣ A denotes the nᵗʰ Redacted Multiplication of A; the product of the elements of A after n layers have been removed in every dimension:  ³×ᵣ [3,2,1,1,2,3,1,1] = ∏ [1,2] = 2 // 1D: remove leading and trailing elements  Then +ᵤ A denotes the nᵗʰ Undone Multiplication of A; the nᵗʰ Redacted Multiplication of A times the product of the elements of A:  ³×ᵤ [3,2,1,1,2,3,1,1] = ³×ᵣ [3,2,1,1,2,3,1,1] × ∏ [3,2,1,1,2,3,1,1]  nᵗʰ Undone Average of A Let μ denote the average (arithmetic mean), i.e. μA = (∑A)N and μᵣA denote the nᵗʰ Redacted Average of A; the average of the elements of A after n layers have been removed in every dimension:  ³μᵣ [3,2,1,1,2,3,1,1] = μ [1,2] = 1.5  Then μᵤ A denotes the average of the nᵗʰ Redacted Average of A and the average of the elements of A:  ³μᵣ [3,2,1,1,2,3,1,1] + μ [3,2,1,1,2,3,1,1] ³μᵤ [3,2,1,1,2,3,1,1] = ───────────────────────────────────────────── 2  ## Task With all this in mind, create an interpreter that will evaluate expressions that use the below operations (numbers are just examples). Alternatively, extend the language of your choice to include the notation. 1 + 2 Addition 3 × 4 Multiplication μ [5,6] Average 7 +u [8,9] Undone Addition 9 ×u [1,2] Undone Multiplication 2 μu [3,4] Undone Average  Note that you do not need to implement redacted operations. They were only defined above to facilitate the definitions of the undone operations. You may substitute any ASCII or Unicode symbol for +, ×, and μ as long as you stay consistent: You may not choose * with ×u. Each undone operator has a higher order precedence than their normal counterpart. ## Test cases: 2+u [1,2,3,4,5,6,7]40 1+u [[1,1,3][4,2,5][3,4,1]]26 3×u [3,2,1,1,2,3,1,1]72 3μu [3,2,1,1,2,3,1,1]1.625 0.1 × 2+u [1,2,3,4,5,6,7]4 2+u [1,2,3,4,5,6,7] × 0.14 0+u [[[1,1][3,2]][[1,3][3,1]]]15 1+u [[[0,1,1][2,1,1][1,0,0]][[2,2,2][2,2,0][1,0,2]][[1,2,0][2,1,1][2,1,2]]]34 1×u [[[1,1,2][1,1,1][1,2,1]][[1,2,2][2,2,1][2,2,1]][[1,1,1][1,1,2][2,1,1]]]2048 1μu [[[2,2,3][3,2,1][3,3,3]][[1,3,3][2,1,1][2,1,3]][[2,3,3][3,2,3][3,2,1]]]3.259 • I find the structure of the definitions very confusing. It would help to a) define terms before you use them; and b) be explicit about the domain and range of the operators. I also, possibly as a result of b), fail to understand the examples: ITSM that ²+ᵣ [1,2,3,4,5,6,7] should be a sum over zero elements because by the time you've removed the first two rows and the last two rows you're left with -3 rows. And the test cases are even more confusing: what is [[1,1][3,2]][[1,3][3,1]]? It looks like two matrices side by side, but I didn't see any mention of implicit operators. Jul 12 '16 at 20:57 • @PeterTaylor a) I originally had redacteds before undones, but I wanted to put the focus on the undones. I'll swap again. b) Notice that the input can be n-dimensional, so as [1,2,3,4,5,6,7] is one-dimensional, only the first and last elements in that only dimension need to be stripped off, giving [3,4,5]. The later examples are missing outer brackets, to indicate that they are 3D. Thanks for your feedback! – Adám Jul 13 '16 at 6:01 • 1. There's no way visually to distinguish the 1D examples from the 2D ones. Now that you've added some [] to the test cases, they're better. Why not do the same for the 2D examples: add a [ before the first row and a ] after the last one, as a cue to distinguish them from the 1D cases? 2. If you think that the redacted distract from the undones, you could rephrase undone addition in terms of a convolution with an n-dimensional "matrix" with elements 1 or 2 according to distance from the exterior; then introduce redacted addition as an alternative way of understanding it. Jul 13 '16 at 7:40 • @PeterTaylor 1. is done. I'm not sure how to formulate 2). – Adám Jul 13 '16 at 11:02 # Family Tree, Folder Tree Given a simple family tree in a format reasonably similar to the format outlined below, create a file tree to match it, as explained below. Input An ascii family tree in a similar format to the following:  Grandpa Jim = Grandma Jane | ------------------------------------------------------- | | | | Bill Bob Jim Jane Sam Sammyson = Aunt Jimbo Daddy McDad = Mommy McMom | | ----------- Me | | Cousin One Cousin Two  The scheme can be changed within reason, however the test cases provided will meet the following specs: 1. = Symbolizes a marriage 2. If there are any children from a marriage, there will be a | one line below the = symbolizing the marriage. 3. A - character that is below a |, or connected (by adjacency) to a - that is immediately below a | are used to signify multiple children. Below any of these - there may be a |, which will have a the first word of a name immediately below it. This full name is the name of a child. 4. The initial line of the family tree will only contain two people. This spec maybe should be cleaned up more. Note that there won't be any relationships more complicated than = marriage or | child linking two names. This means that more complicated relationships, such as divorce or step-children, will not appear in the tree. Output There will be no output as such, instead the program/function will create a directory structure matching the input. For example, the above example would lead to the following directory tree: $ tree family_tree/
family_tree/
├── Grandma Jane
│   ├── children
│   │   ├── Bill Bob
│   │   │   └── parents
│   │   │       ├── Grandma Jane -> ../../../../Grandma Jane/
│   │   │       └── Grandpa Jim -> ../../../../Grandpa Jim/
│   │   │   ├── children
│   │   │   │   └── Me
│   │   │   ├── parents -> ../Jim Jane/parents
│   │   │   └── spouse
│   │   │       └── Mommy McMom
│   │   │           ├── children -> ../../children/
│   │   │           └── spouse
│   │   ├── Jim Jane
│   │   │   └── parents -> ../Bill Bob/parents/
│   │   └── Sam Sammyson
│   │       ├── children
│   │       │   ├── Cousin One
│   │       │   └── Cousin Two
│   │       ├── parents -> ../Jim Jane/parents
│   │       └── spouse
│   │           └── Aunt Jimbo
│   │               ├── children -> ../../children/
│   │               └── spouse
│   │                   └── Sam Sammyson -> ../../../../Sam Sammyson/
│   └── spouse
│       └── Grandpa Jim -> ../../Grandpa Jim/
└── Grandpa Jim
├── children -> ../Grandma Jane/children/
└── spouse
└── Grandma Jane -> ../Grandma Jane/


The directory tree must satisfy the following:

1. Create a directory called family_tree that will contain the entire family tree.
2. Inside family_tree/ there will be exactly two directories, these are the two people at the top of the family tree.
3. For every person in the tree, do the following in their directory:
1. If they have a spouse, create a spouse directory. If the spouse already has a directory named after them, create a link to that directory within the spouse directory. Otherwise, create a directory in the spouse directory with the name of the spouse.
2. If they have children, then they must have a spouse. If the spouse already has a directory named children, then create a link to that directory and name the link children. If their spouse doesn't already have this directory, create the children directory and add a directory corresponding to each child.

Again, this is a rough draft. The spec needs to be cleaned. I welcome comments

Note that, in all cases, it does not matter where the true directory and where the link is, as long as the link is properly setup. Also, it is okay to create links to other links.

Also, link means symbolic link throughout the challenge.

This is

# The French Farmer in the Dell

I used to work with kids and The Farmer in the Dell was a popular song among them. Also, I like challenge like 99 bottles of beer or Polar Bear, Polar Bear, what do you hear?. Try them too!

## Goal

In your programming language of choice, write the smallest program possible which will output the following text. Output should match exactly, including case, spacing, and punctuation. A trailing linefeed is fine but specify it in your answer. We will play with the french version of the song because I find it more interesting than the english version (also I am french so more memories for me!).

Le fermier dans son pre,
Le fermier dans son pre,
Ohe, Ohe, Ohe,
Le fermier dans son pre.

Le fermier prend sa femme,
Le fermier prend sa femme,
Ohe, Ohe, Ohe,
Le fermier prend sa femme.

La femme prend son enfant,
La femme prend son enfant,
Ohe, Ohe, Ohe,
La femme prend son enfant.

L'enfant prend sa nourrice,
L'enfant prend sa nourrice,
Ohe, Ohe, Ohe,
L'enfant prend sa nourrice.

La nourrice prend son chat,
La nourrice prend son chat,
Ohe, Ohe, Ohe,
La nourrice prend son chat.

Le chat prend sa souris,
Le chat prend sa souris,
Ohe, Ohe, Ohe,
Le chat prend sa souris.

La souris prend son fromage,
La souris prend son fromage,
Ohe, Ohe, Ohe,
La souris prend son fromage.

Le fromage est battu,
Le fromage est battu,
Ohe, Ohe, Ohe,
Le fromage est battu.


If you are french, you may note that I replace all é with e. It is not important for the challenge and I prefer to stay full ASCII.

If you want to code while listening to the song, you can find it on YouTube. :)

## Sandbox Questions

A not so difficult challenge. I originally thought about posting it directly, but I prefer to share it first. I don't think test case are needed. I implemented both the english and french version and the last one is far better to my taste :)

• The only thing I'd be worried about is if this is a duplicate of something. If the structure of the song is too similar to another one I think it should be closed. That said, this is pretty similar to the polar bear song, but without a second verse type and with an exception or two? I don't know whether that is enough, so I wouldn't vote to close on my own. Jul 20 '16 at 19:14
• This looks vulnerable to the techniques which have been used on previous songs, the canonical example of which is the rickroll. Jul 21 '16 at 7:39

## Background

As you may or may not be aware, Pokemon Go's servers have not fared well under the stress of the game's extreme popularity. As an amateur programmer, I'm in the sweet spot where I know just enough to think I can solve all of their problems, but not enough to be able to understand how complex their problems actually are. Thus, I find myself constantly thinking "Why didn't they just do <insert naive suggestion here>? It would fix everything!" This challenge is focused on one of those probably-useless ideas I've thought up.

First, some very quick background, in case you haven't played the game (you can skip this paragraph if you have): In the course of gameplay, Pokemon can randomly appear at certain real-life locations. Every player in the same location sees the same Pokemon, and multiple players can catch one Pokemon.

One potential difficulty I see with this is storing all of that data. With millions of concurrent players, the game servers have to keep track of millions of Pokemon. That's a lot of IO for their database. Fortunately, I, a graduate of not one, but two introductory CS courses, have a solution! Because player interactions have nothing to do with where and when Pokemon spawn, it is essentially deterministic. This means that it should be possible to drop the database entirely (at least for this one specific task), and replace it with a function! This function could take the player's location, the current system time, and a random seed as input, and return a list of all Pokemon within a certain radius. Because no database lookup is needed, this function would be lightning fast and easily scalable to millions of players.

## The Challenge

Your challenge is to write this function. Obviously, the actual game of Pokemon has way too many details to make a feasible code challenge for PPCG, so here's the simplified guidelines:

• Create a function that takes the following inputs, in any format you like:
• Player location, as 2D coordinates
• System time
• Random seed
• The function should return a list of nearby Pokemon, with the following requirements:
• "Nearby" means "within one unit of distance of the player", where distance is 2d euclidean distance. (Just ignore the edge case where the location is on a round planet)
• Each Pokemon should have a species and an exact location
• This list can be in any format you want
• The results are deterministic (i.e., for the same location, time, and random seed, the same Pokemon are always returned)
• The Pokemon should persist for some pseudorandom amount of time
• Thus, if the function is called twice with the same location and random seed, and two times that are very close, then each Pokemon returned the first time should have a large possibility of being returned the second time
• If the function is called twice with the same time and random seed, and two nearby locations, then any Pokemon that are near both locations should be returned both times
• The Pokemon should be somewhat evenly distributed across the "world" (the coordinate plane).
• The Pokemon should be distributed such that at any location and time, the probability of finding exactly n nearby Pokemon of any type is (0.5)^(n+1)
• Thus, there is a 50% chance of finding no Pokemon at all, a 25% chance of finding exactly 1, a 12.5% chance of finding exactly two, etc.
• Your algorithm should be capable of returning up to 10 nearby Pokemon, but is allowed to return more, as long as it follows the right probability distribution
• Sandbox question: I want a requirement to be that the algorithm can't simply generate all of the Pokemon in the world and then just return the nearby ones, but I don't know how to formally state this. I had some fleeting thoughts about O(1) memory usage, but that method could strictly speaking have O(1) memory usage if the world is a constant size (which I'm pretty sure it is).

Might this make a good challenge? That would fit in with the premise, and might produce some interesting algorithms.

For the sake of making this challenge somewhat reasonable, the list of possible Pokemon and their probabilities of appearing will be small:

• Weedle: 60%
• Charmander: 30%
• Blastoise: 10%

## Scoring

This is part of what I need help with in the sandbox. How should I distinguish two entries that both meet all of the requirements?

Thanks for reading this far! I know this question isn't nearly ready to be a real challenge. At the very least, it need more specific requirements. But I figured I'd post what I currently have in the sandbox to see if it's worth continuing with. I've never posted or participated in a PPCG challenge before, and I'm sure that's obvious, but hopefully with your help, I can refine this to the point of being a legitimate challenge.

• Welcome to PPCG, and thanks for using the sandbox! :) Currently I'm afraid your question is rather underspecified. You need to define "nearby" as well as describe how Pokemon should be distributed, as otherwise I could just put 6 weedles, 3 charmanders and a blastoise on the north pole for some time, then swap them to the south pole, etc. You could put a time constraint on the code to try to limit the whole world generation problem, but to do that you'd probably need a reference implementation. Personally, I think code-golf is likely the best scoring method. Jul 22 '16 at 15:25
• I was imagining this challenge would be very difficult and require a somewhat complex answer, which is why I didn't initially tag it as code golf. But after thinking about it for a little while, I came up with a rather simple solution that isn't as interesting as I thought it would be. So maybe code golf is a better tag. As for you other remarks, I'll get to work editing the answer to make it less ambiguous. Jul 22 '16 at 15:39
• 1. Does "the usual euclidean distance" mean in the 3D embedding of the globe whose surface is parameterised by the input coordinates? Or have you decided to simplify by ignoring the fact that real Pokémon Go takes place on a round planet? 2. What does "as long as it follows the right probability distribution" mean if you curtail the probability distribution? What happens to the probability from the tail? Jul 22 '16 at 21:43
• @PeterTaylor: I have answered both of your questions by editing my post. Thanks for the feedback! Jul 22 '16 at 21:53

# Punch Buggy Probabilities

A popular game among children in the USA is "punch buggy", and as with every such game, there are many variations. The one we'll consider for this challenge goes like this:

• The moment anyone sees a Volkswagon Beetle (the "buggy"), participants may punch each other (usually in the shoulder or upper arm).
• A punch must be accompanied by "punch buggy <color>!", where <color> is the color of the VW Beetle (red, green, black, gray, yellow, etc.).
• Whoever makes contact first gets priority (and for this challenge, there are no ties).
• Once person A punches person B, B cannot punch A back (usually accomplished by saying "no punch back!").
• Punches may occur between any pair of participants (for this challenge, every pair of participants).

## The challenge

Assuming all possible punching configurations among n people are equally likely to happen, what is the probability of any particular punching configuration? To put it another way, for each distinct punching configuration, how many ways can it occur?

## Rules

• Input is a single positive integer greater than 1.
• Output must be one of the following: A) a list of decimals, B) a list of fractions (simplified or not), or C) a list of counts. META: Should I allow these lists to be unordered, or should I require that they be associated with punching configurations somehow? I'm leaning towards the former since it seems like it'd be a headache to figure out how to specify the latter and it would likely be an extra task that doesn't really have anything to do with the core problem.
• Standard rules apply, and standard loopholes are banned.

## Test cases

Input
Output A
Output B
Output C

2
1.0
2/2
2

3
0.75 0.25
3/4 1/4
3 1


Explanation of input 2: With only two people, there are exactly two possible ways: either A punches B or B punches A. These are equivalent, so the probability is 1.0, the fraction is 2/2, and the count is 2.

Explanation of input 3: There are two distinct punching configurations: A -> B -> C, A -> C; A -> B -> C -> A. The latter has only two varieties (the other is A -> C -> B -> A) and the former has six, since there are three choices for the person who punches two others and then two choices for the remaining pair. Thus, the probabilities are 0.75 and 0.25, the fractions are 3/4 and 1/4, and the counts are 3 and 1.

## META

• I want to add 4 to the test cases, and I think I'm gonna need help on it since I'm having a hard time counting all 2^6 = 64 possibilities correctly.
• Any clarifications/corrections?

# Teh Scrolling Codez

In many movies, computer often appear to be scrolling through some code. We should automate this process to make it easier. Your job is to write code that displays to a graphical console a scrolling view of its own source code. You have two options...

## Sandbox Questions

Should this be a code golf or pop-con. Pop-con's could result in more visually pleasing solutions. or [tag:popularity contest]

• I'm wondering how you vertically scroll source code that's one line. Jul 28 '16 at 1:17
• SIngle line source code is permitted. That is why it may make more sense to scroll it horizontally @feersum Jul 28 '16 at 2:13
• A quine in a loop and rely on the console having finite height? Jul 28 '16 at 8:07
• Yeah that could work Jul 28 '16 at 12:18
• @PeterTaylor ^^ Jul 28 '16 at 12:18
• @PeterTaylor do you have an opinion on what tag should be used? Jul 28 '16 at 12:21
• I suspect that this applies and that it's not an interesting question, although I personally don't find quines interesting so I'm not the best person to comment on that. Jul 28 '16 at 13:32
• but F() in and of itself is an interesting challenge. @PeterTaylor Jul 28 '16 at 15:37
• F(P) is while(true) print P. That's not an interesting challenge in any language I know. Jul 28 '16 at 16:10
• @PeterTaylor than I think I should ban console output, and require graphical output Jul 28 '16 at 16:12
• thus F(P) becomes while(true){print(sectionOf(p))move(p)}; Jul 28 '16 at 16:13

# Autonomous Vehicle

I need a brain for my self-driving car. Something that will take still frames from the front-facing camera and give the navigation system commands. Obviously, if my car is driving me somewhere, I don't want to stop. However, I also don't want to:

1. Kill someone
2. Die

Knowing myself, we can assume that:

• At the speed I drive, hitting the curb or otherwise leaving the road will kill me and thus violate Don't #2
• With my luck, running a stop light, will violate Don't #1 or #2 or both

• Also hitting a pedestrian (or another car) violates Don't #1 (and possibly #2)

## Input

The program/function should take an image as input. How it does this is flexible.

## Output

The program/function should output one of these commands; ideally, one of the commands that doesn't result in one of the Don'ts being violated.

╔═════════╤═══════════════════════════════════════════════╗
║ Command │ Navigational Outcome                          ║
╠═════════╪═══════════════════════════════════════════════╣
║ Forward │ No course correction, continue straight ahead ║
╟─────────┼───────────────────────────────────────────────╢
║ Left    │ Veer left                                     ║
╟─────────┼───────────────────────────────────────────────╢
║ Right   │ Veer right                                    ║
╟─────────┼───────────────────────────────────────────────╢
║ Stop    │ Screech to a grinding halt                    ║
╚═════════╧═══════════════════════════════════════════════╝


## Specifications

• Take an image as input in someway
• Output a command [ Forward, Left, Right, Stop ]
• Commands can be aliased as [ 0, 1, 2, 3 ] respectively
• Returning one valid command and no invalid commands is sufficient to pass a test
• Stop is only valid iff every other command would violate one of the Don'ts
• Rules for valid commands:
• No running stop lights
• No running over people
• No running into vehicles
• No running off the road
• If a command does not violate any of the above, then it is valid
• Program/Function must be deterministic

# Scoring

Lowest score wins! The scoring function is:

• ( # of Bytes ) / ( Number of Passed Tests )

For example, a 450 byte Python solution that passes 2 test cases earns a score of 450 / 2 or 225.

## Test Cases

1. Valid Commands: Forward

2. Valid Commands: Left, Right

• Straight ahead there are pedestrians crossing

1. Valid Commands: Forward, Right

2. Valid Commands: Forward

3. Valid Commands: Left, Right

4. Valid Commands: Stop

• I like this challenge. However, I don't see any test cases for lights. I also think that the test case for pedestrians is pretty bad. Also, realize that people might be using the text on the images (the road labels) to determine orientation, so make sure you're ok with that. I'd also recommend more test cases. Your current set is a good example set, but not comprehensive enough for testing IMO. Jul 30 '16 at 1:19
• will all testcases be available? if so i would determine the output by the value of the pixel in the top-left corner. Jul 30 '16 at 19:47

## Embed a graph into the Rado graph

The Rado graph is an infinite undirected graph whose vertices are labelled with natural numbers {0, 1, 2, ...}.

The edge (i,j) with i<j is in the graph whenever the binary expansion of j has a 1 in its ith place. Here, place values are counted from the end, with the 0'th place being the least significant bit. In terms of bitshifts, this means (j>>i)&1==1.

The Rado graph is universal in that any finite graph is a subgraph of it. This means that any finite graph can be embedded in the Rado graph: to each vertex of the finite graph, assign a distinct vertex of the Rado graph so that any two vertices of the original graph have an edge if and only if the corresponding vertices of the Rado graph have an edge.

Your task is to output such an embedding for a finite graph given as input.

TODO: Lots of stuff

• Lovely challenge :). Is there a known algorithm to find the embedding? If so, might it be worth linking to it with a spoiler warning? Jul 31 '16 at 10:05
• 1. It would be more accurate to say that this is one of several constructions of the Rado graph, and to state that answers are required to work with this construction in particular. 2. The statement of universality is incorrect. It should say induced subgraph rather than subgraph. 3. I assume that by "an embedding" you mean a mapping from vertices of the input graph to vertices of this construction of the Rado graph, but it would be good to make that explicit. 4. @MartinEnder, there's a greedy algorithm described in Wikipedia. Jul 31 '16 at 20:02

# Draw Concentric Squarephabets

## Challenge

Write a program or function that, given an input integer n, outputs a concentric squarephabet of size n×n.

A concentric squarephabet is an ASCII-art square of concentric rings, where the outside ring of characters are As, the second Bs, the third Cs, etc. For example, a 25×25 squarephabet looks like this:

AAAAAAAAAAAAAAAAAAAAAAAAA
ABBBBBBBBBBBBBBBBBBBBBBBA
ABCCCCCCCCCCCCCCCCCCCCCBA
ABCDDDDDDDDDDDDDDDDDDDCBA
ABCDEEEEEEEEEEEEEEEEEDCBA
ABCDEFFFFFFFFFFFFFFFEDCBA
ABCDEFGGGGGGGGGGGGGFEDCBA
ABCDEFGHHHHHHHHHHHGFEDCBA
ABCDEFGHIIIIIIIIIHGFEDCBA
ABCDEFGHIJJJJJJJIHGFEDCBA
ABCDEFGHIJKKKKKJIHGFEDCBA
ABCDEFGHIJKLLLKJIHGFEDCBA
ABCDEFGHIJKLMLKJIHGFEDCBA
ABCDEFGHIJKLLLKJIHGFEDCBA
ABCDEFGHIJKKKKKJIHGFEDCBA
ABCDEFGHIJJJJJJJIHGFEDCBA
ABCDEFGHIIIIIIIIIHGFEDCBA
ABCDEFGHHHHHHHHHHHGFEDCBA
ABCDEFGGGGGGGGGGGGGFEDCBA
ABCDEFFFFFFFFFFFFFFFEDCBA
ABCDEEEEEEEEEEEEEEEEEDCBA
ABCDDDDDDDDDDDDDDDDDDDCBA
ABCCCCCCCCCCCCCCCCCCCCCBA
ABBBBBBBBBBBBBBBBBBBBBBBA
AAAAAAAAAAAAAAAAAAAAAAAAA


(and yes I typed that by hand ☺)

If the input is an even number, the centre of the squarephabet will be a 2×2 square instead of a single letter. For example, for input 8:

AAAAAAAA
ABBBBBBA
ABCCCCBA
ABCDDCBA
ABCDDCBA
ABCCCCBA
ABBBBBBA
AAAAAAAA


## Specification

• Standard loopholes are forbidden.
• The input to your program or function will never be less than 1 or greater than 52 (26×2). This means you do not have to deal with letters after Z.
• You may output uppercase or lowercase letters, but you must be consistent in your choice.

## Test Cases

Format:

Input
Output


Test cases:

1
A

2
AA
AA

3
AAA
ABA
AAA

10
AAAAAAAAAA
ABBBBBBBBA
ABCCCCCCBA
ABCDDDDCBA
ABCDEEDCBA
ABCDEEDCBA
ABCDDDDCBA
ABCCCCCCBA
ABBBBBBBBA
AAAAAAAAAA

25
AAAAAAAAAAAAAAAAAAAAAAAAA
ABBBBBBBBBBBBBBBBBBBBBBBA
ABCCCCCCCCCCCCCCCCCCCCCBA
ABCDDDDDDDDDDDDDDDDDDDCBA
ABCDEEEEEEEEEEEEEEEEEDCBA
ABCDEFFFFFFFFFFFFFFFEDCBA
ABCDEFGGGGGGGGGGGGGFEDCBA
ABCDEFGHHHHHHHHHHHGFEDCBA
ABCDEFGHIIIIIIIIIHGFEDCBA
ABCDEFGHIJJJJJJJIHGFEDCBA
ABCDEFGHIJKKKKKJIHGFEDCBA
ABCDEFGHIJKLLLKJIHGFEDCBA
ABCDEFGHIJKLMLKJIHGFEDCBA
ABCDEFGHIJKLLLKJIHGFEDCBA
ABCDEFGHIJKKKKKJIHGFEDCBA
ABCDEFGHIJJJJJJJIHGFEDCBA
ABCDEFGHIIIIIIIIIHGFEDCBA
ABCDEFGHHHHHHHHHHHGFEDCBA
ABCDEFGGGGGGGGGGGGGFEDCBA
ABCDEFFFFFFFFFFFFFFFEDCBA
ABCDEEEEEEEEEEEEEEEEEDCBA
ABCDDDDDDDDDDDDDDDDDDDCBA
ABCCCCCCCCCCCCCCCCCCCCCBA
ABBBBBBBBBBBBBBBBBBBBBBBA
AAAAAAAAAAAAAAAAAAAAAAAAA

52
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
ABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBA
ABCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCBA
ABCDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDCBA
ABCDEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEDCBA
ABCDEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEDCBA
ABCDEFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGFEDCBA
ABCDEFGHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHGFEDCBA
ABCDEFGHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIHGFEDCBA
ABCDEFGHIJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJIHGFEDCBA
ABCDEFGHIJKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKJIHGFEDCBA
ABCDEFGHIJKLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLKJIHGFEDCBA
ABCDEFGHIJKLMMMMMMMMMMMMMMMMMMMMMMMMMMMMLKJIHGFEDCBA
ABCDEFGHIJKLMNNNNNNNNNNNNNNNNNNNNNNNNNNMLKJIHGFEDCBA
ABCDEFGHIJKLMNOOOOOOOOOOOOOOOOOOOOOOOONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPPPPPPPPPPPPPPPPPPPPPPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQQQQQQQQQQQQQQQQQQQQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRRRRRRRRRRRRRRRRRRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTTTTTTTTTTTTTTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUUUUUUUUUUUUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVVVVVVVVVVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWWWWWWWWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXXXXXXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXYYYYXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXYZZYXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXYYYYXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXXXXXXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWWWWWWWWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVVVVVVVVVVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUUUUUUUUUUUUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTTTTTTTTTTTTTTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRRRRRRRRRRRRRRRRRRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQQQQQQQQQQQQQQQQQQQQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPPPPPPPPPPPPPPPPPPPPPPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOOOOOOOOOOOOOOOOOOOOOOOONMLKJIHGFEDCBA
ABCDEFGHIJKLMNNNNNNNNNNNNNNNNNNNNNNNNNNMLKJIHGFEDCBA
ABCDEFGHIJKLMMMMMMMMMMMMMMMMMMMMMMMMMMMMLKJIHGFEDCBA
ABCDEFGHIJKLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLKJIHGFEDCBA
ABCDEFGHIJKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKJIHGFEDCBA
ABCDEFGHIJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJIHGFEDCBA
ABCDEFGHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIHGFEDCBA
ABCDEFGHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHGFEDCBA
ABCDEFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGFEDCBA
ABCDEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEDCBA
ABCDEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEDCBA
ABCDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDCBA
ABCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCBA
ABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA


## Scoring

This is , so shortest answer wins. Good luck!

• We're getting slightly into idea-milking territory here. While this isn't a bad idea, a lot of similar challenges in short succession tend to lose interest and popularity fast so you might want to think twice whether you want to post this any time soon. That said, the construction seems simple enough that I'm pretty sure it's been done before. For instance this challenge requires the exact same computation at the core: codegolf.stackexchange.com/q/57845/8478 (although yours probably allows for other approaches, too). Aug 1 '16 at 16:31

A meander is a self-avoiding closed curve which intersects a line a number of times.

Your task is, given a self-avoiding walk on a lattice/grid, produce a meander a la the following:

Input

{{{3, 4}}, {1, 2}, {2, 6}, {6, 7}, {7, 3}, {3, 4}, {4, 8}, {8, 12}, {12, 11}, {11, 10}, {10, 9}, {9, 5}, {5, 1}}


Output

or similar.

# Test cases:

Inputs

a={{{3, 5}}, {{1, 2}, {2, 3}, {3, 8}, {8, 9}, {9, 4}, {4, 5}, {5, 10}, {10, 15}, {15, 14}, {14, 13}, {13, 8}, {8, 7}, {7, 12}, {12, 11}, {11, 6}, {6, 1}}}
b={{{3, 6}}, {{1, 2}, {2, 8}, {8, 9}, {9, 3}, {3, 4}, {4, 10}, {10, 11}, {11, 5}, {5, 6}, {6, 12}, {12, 18}, {18, 17}, {17, 16}, {16, 10}, {10, 9}, {9, 15}, {15, 14}, {14, 13}, {13, 7}, {7, 1}}


Output

In the above examples, the numbers correspond to a grid, bottom to top, left to right, so 1 is bottom-left, and 18 on a 3*6 grid is top-right. The orientation of your grid doesn't have to follow this order: it can have any desired orientation.

You can assume dimensions of the grid are given at the begining of the input, as per the obove examples.

Feel free to use either pre-existing images - eg

or generate your own. This is Code Golf, so the shortest answer in bytes wins.

• I'm still not clear how the points relate the the final image. For the pre-existing images, can we use them at no bytes cost? Is the code for loading them free?
– xnor
Aug 4 '16 at 10:44
• @xnor I think you are right - it is not clear as it stands - think I will leave it on the back-burner for the moment. Aug 4 '16 at 12:31

## ASCII Art converter

see ASCII Art on Esolangs

Your task is to take input of a brainf*** program and output its equivalent ASCII art program. Your challenge: You may not use the following symbols in your program: \ / - | _ # Standard loopholes not allowed...

This is a so shortest answer in bytes wins

## ACII Art Interpreter

Your task is to create an interpreter for the ASCII art language. ASCII Art is a variant of brainf*** where characters are instead ASCII art figures 5 lines tall.

< looks like

 /
/
\
\


> looks like

\
\
/
/


+ looks like

  |
|
-----
|
|


- looks like

-----


[ looks like

____
|
|
|
|___


] looks like

____
|
|
|
___|


. looks like

##
##


, looks like

##
##
_|


Characters that are less than 5 characters tall may be placed anywhere within the top line and bottom line of input.

____________________ top line
\
\
/
/
<--- gap because this char is only 5 characters tall
_____________________bottom line


There may be any amount of white space between characters. Also characters can be "nested" in each other, as long as they do not touch. EG

____ |  ##
|    |  ##
|  -----_|
|    |
|___ |


is perfectly valid

Your code should not allow improperly formatted ASCII art, and should print to Standard error. For example, the following code should not work

\
\
|
|
|____


This is a , so the shortest answer in bytes wins!

• What is the winning criterion (is it codegolf, popularty contest, anything else...), and what is the font to use? Aug 3 '16 at 17:06
• @TùxCräftîñg By font, what do you mean - the ASCII art page on esolangs depicts what each and every symbol should look like Aug 3 '16 at 17:31
• Nevermind, I haven't seen this part Aug 3 '16 at 17:39
• Welcome to PPCG and thanks for using the sandbox! Unfortunately, this is basically a dupe of this challenge with a do X without Y bit tacked on, so I don't think this will be received well. I'm not really sure if there is a way to salvage your intent, here, but I recommend trying something different. Best of luck! Aug 3 '16 at 17:45
• 1. If at all possible, posts should be self-contained. The Esolangs page you link to might change or disappear. 2. You should specify how the commands should be chained (horizontally, vertically or something else), how they should be aligned, and how much whitespace has to separate them. 3. In my opinion, forbidding those characters doesn't make the challenge more interesting. Aug 3 '16 at 17:49
• @FryAmTheEggman Except my challenge is meant to convert only brainf*** code Aug 3 '16 at 17:49
• I'm afraid that isn't nearly enough to make it not a duplicate, in my opinion. However, Dennis brings up a potentially interesting point, you may be able to salvage this by also requiring that the code be "formatted" a certain way. I also agree with the rest of the advice Dennis gave you, and I think you should address them before deciding on what else to do. Aug 3 '16 at 17:52
• What if I change it to a ASCII art interpreter Aug 3 '16 at 17:57

# Find the Watermark

At the moment, I don't have time to outline this properly. The idea is simple: Find the watermark in an image. The implementation, however, is obviously not simple. Since watermarks can have a variety of characteristics, I'd like to admit a variety of answer styles and make it a . Some ideas for the output format:

• Return coordinates of the (centre|corner(s)?) of the watermark
• Return a line in some form (e.g., endpoints or equation) that runs through the watermark
• Return an image that contains only a mask matching the watermark

Input, obviously, would be an image containing a watermark. Images without watermarks are not valid input; as such, submissions do not need to handle them in any special way.

• I fear that this is far too vague, and probably too difficult.
– Joe
Aug 21 '16 at 2:10
• Maybe a test-battery tag? Aug 21 '16 at 2:19
• Yes, seeing the proposed test cases would give a much better idea of whether this is realistic. Aug 21 '16 at 7:40
• I hereby encourage any member of the community to take over this challenge. I have no experience with graphical I/O, and I don't foresee myself gaining any in the near future. I doubt that I can write a reasonable spec; also, I'm just not that interested in it anymore.
– Joe
Sep 5 '16 at 20:37

# whispering and SHOUTING

Typing in all caps on the internet is often called "shouting". For the sake of this challenge, I'll call typing in all-lowercase "whispering".

## The challenge

Write a complete program that can be run in two different ways: whispering and shouting. The "whispering" version of the program must be written in all-lowercase characters, and it should print whisper to STDOUT. The "shouting" version of the program will print SHOUT. The shouting version must be the exact same program as the whispering version, but with all lowercase letters replaced by the uppercase version of the letter. Everything else must be identical.

## Rules

• No standard loopholes
• This is , so shortest program in bytes wins!
• Is shortest program in bytes? Aug 21 '16 at 2:46
• Yes, I'll clarify that Aug 21 '16 at 2:46
• Though I'm not too sure if I want to keep the restriction of not containing the words because it feels kind of arbitrary and that isn't the point of the challenge Aug 21 '16 at 3:52
• It may be a "Do X without Y" question, which could be bad if not done carefully. Aug 21 '16 at 3:53
• @ColdGolf The difference between this and a do X without Y is that this challenge focuses on actually doing the X (a non-trivial task) instead of focusing on not using Y. Still, I think I'll get rid of the restriction because a) I'd like to focus more on the X and b) the restriction is trivial to circumvent (simply use concatenation) Aug 21 '16 at 3:59
• What about characters that don't have a case? Or characters that have more than two cases? Is the program restricted to ASCII? Aug 21 '16 at 4:13
• @FryAmTheEggman characters without a case don't have to change. What character has more than 2 cases? And it's whatever encoding the program uses. Aug 21 '16 at 11:54
• Sigma has three total variants. Not restricting this to ASCII makes it seem rather odd. Couldn't a language totally avoid the problem by writing the program in caseless characters and then checking like A > 65? Additionally, some characters (i.e. small caps) look like they should have lower case variants, but don't AFAIK. What standard of considering things lower case should we follow? Without restricting or clarifying this, I think this is too unclear. Aug 21 '16 at 13:31

# Switching lines

Let's say you have a string of text:

Hello, World! Today is a
most glorious day. In fact,
it's another day. Woohoo!


This string has three lines. We can call them lines 1, 2, and 3. (Or, if you prefer zero-indexing, lines 0, 1, and 2. I'll be using one-indexing to describe this challenge.)

Let's also say we have a mapping of line numbers to line numbers, such as 1 => 2, 3 => 1, 2 => 3. We will interpret this mapping as a method of "switching" lines with each other; the first rule switches line 1 with line 2, then line 3 with line 1, then line 2 with line 3. This would make the string look like, with intermediate steps:

Rule: (initial)
1. Hello, World! Today is a
2. most glorious day. In fact,
3. it's another day. Woohoo!

Rule: 1 => 2
2. most glorious day. In fact,
1. Hello, World! Today is a
3. it's another day. Woohoo!

Rule: 3 => 1
2. most glorious day. In fact,
3. it's another day. Woohoo!
1. Hello, World! Today is a

Rule: 2 => 3
3. it's another day. Woohoo!
2. most glorious day. In fact,
1. Hello, World! Today is a


Notice how the rule describes lines to be switched, not merely lines in that index. So each line has a permanent, associated line number.

Any rule such as 1 => 1 is effectively a no-operation.

Objective Given a list of numbers in any convenient format (e.g. an array of pairs of integers, a list like A B\nC D, a list of numbers, etc.) and a non-empty string of text, perform the action described above.

## Meta

is it a good idea to do line identity instead of line locations?

• So the requirements are 1) number the lines; 2) apply the permutation which results from composing a series of simple swap permutations, each of which must be interpreted in the light of the previous ones? The lines really seem to be superfluous: the core of the question is the permutations, surely? Aug 27 '16 at 19:13
• @PeterTaylor I suppose that's true. It would certainly simplify the questions. Aug 27 '16 at 19:26

# Tweetable Video

This challenge is inspired by the Encode Images into Tweets challenge, extending the idea to now attempt to compress video into a series of "tweet" sized messages where the number of tweets == number frames of the video.

The competition is to compress 450 frames of video into 450 (or less) tweets of 140 charactes ( 114.97 bytes per tweet, total max 51737 bytes).

Original frames as Video, as PNG images [Sandbox note: Higher quality version will be uploaded soon]

Reference solution frames as Video [Sandbox note: Reference solution will be expanded once challenge changes stabilized]

### Rules:

These rules are the based from rules in Encode Images into Tweets modified to accommodate multiple frames that will yield the resultant video.

1. You must write a program that will communicate via std in/out based on the communication protocol defined below, ultimately producing a series of tweets that will, when fed back to your program, produce image frames of the video.
2. The text created for each 'Tweet' by the program must be at most 140 characters long and must only contain characters whose code points are in the range of 32-126, inclusive.
3. The source video will be 450 frames of Big Buck Bunny. Frames can be downloaded here
4. Frames will be width 320 pixels and height 240 pixels @ 24 bit RGB, each channel having 8 bit precision.
5. Your program should be able to compress other video sources at same resolution.
6. Your program can use external libraries and files, but cannot require an internet connection or a connection to other computers.
7. The decoding process cannot access or contain the original images in any way. (Clarification use of corpus images is allowed as long as these images do not contain direct or manipulated original image frames)
8. Use of video codecs or existing libraries that perform video compression are not allowed. This is to encourage experimentation and originality rather than simply calling libraries. Note that use of static image compressors/ libraries are allowed.
9. Standard Loopholes are forbidden.

### Communication Protocol

1. All communication is via std in/out.
2. The controller program will launch your program with no command line arguments.
3. The controller will either initiate a one of the following sequences commanding to your program and expecting results.

Note the sequences are described below in the following format:

<Comms direction from controller perspective>, <seq number>: <Transmitted Data> - <Information>


For Encoding of the frames:

Output, 1: ENCODE\n - Indicating that the controller will be sending frames for your program to compress.
Output, 2: <number of frames>\n - String indicating number of frames. i.e. 450
Output, 3: <number of bytes for image data>\n - String indicating number of bytes of the current image data. e.g. 32145
Output, 4: <image data> - sequence of bytes of length defined in output line 3. The is the image data. The image data is a 24 bit image in PNG format
Repeat from output seq number 3 for the number of frames in output seq number 2.
Input, 1: <Tweet>\n - encoded image data. upto 140 characters, whose code points are in the range of 32-126, inclusive. A zero sized tweet will indicate end of all tweets.
Repeat from input line 1 for 1 to up to the number of frames in output seq number 2. Note a zero sized tweet will indicate end of all tweets.
Output, 5: END\n - Indicating that all processing has finished and your program should quit gracefully.


For Decoding of the frames:

Output, 1: DECODE\n - Indicating that the controller will be sending tweets for your program to decompress.
Output, 2: <number of tweets>\n - String indicating number of tweets. i.e. 450
Output, 3: <Tweet>\n - encoded image data. upto 140 characters, whose code points are in the range of 32-126
Input, 1: <number image frames decoded>\n - String indicating number of image frames that have been decoded as a result of the provided tweet. If 0 then no images have been decoded for this tweet.
Input, 2: <number of bytes for image data>\n - String indicating number of bytes of the current image data. e.g. 32145.
Input, 3: <image data> - sequence of bytes of length defined in input line 2. The is the image data. The image data is a 24 bit image in PNG format.
Repeat from input seq number 2 for the number of frames in input seq number 1.
Repeat from output seq number 3 for the number of tweets in output seq number 2.
Output, 4: END\n - Indicating that all processing has finished and your program should quit gracefully.

1. Your program will be restart between the encoding and decoding phases.

### Scoring

As an attempt to model the human visual system in a simplistic manner, JPEG quality levels are used as an analogue. Each frame will be compressed to a JPEG using quality levels 0.01 to 1.0 in 0.01 increments. The PSNR of these JPEG compressed versions are calculated and added into a data structure. Additionally, each frame will be resized by half and the JPEG encoding and PSNR calculations performed and added to the data structure. The resizing and calculating will repeat until a single pixel is left.

The result of which will be a scoring continuum of visual 'quality' from low (single color frame) to High (near-identical to original).

Thus, scoring will be objective by means of the following formula:

JPEG_QUALITY_LEVEL_PSNR = a pre-computed data multi dimensional structure consisting of the
PSNR for incremental JPEG quality levels for each image frame of
the video. The entries into this structure for each frame is such
that higher indecies are deemed to be of more similar to the
original.

Score = SUM of (index of closest matching entry in JPEG_QUALITY_LEVEL_PSNR for given
original frame and given PSNR of decoded frame)


### Controller

[Sandbox note: Controller is to be created]

### Refrence Solution

[Sandbox note: Reference is to be created once question stabilizes]

## Sandbox Questions

Ok, so this is my first question ever posed to codegolf and I am very keen to get feedback on how to better present the challenge.

Some areas where I would like specific feed back is the objective scoring mechanism... i purposely avoided direct PSNR as the score as it is very limited for scoring video quality, being biased toward blurry images, however other algorithms are too complex or not defined. So as a compromise I am using JPEG compression as an analogue for the Human Visual System. Effectively matching a given solutions output frame to original frame PSNR to a JPEG compressed, at a given quality level) version's PSNR and using that match's index in sorted JPEG quality order as input for the score.

Is the protocol clear enough? if not what would be a better way to present it?

• "I introduced it so that solutions that take all the frames then perform processing over all the frames would be at a clear advantage over those solutions than work over a much shorter frame period." I'm not seeing it. If I process all of the frames then the first frame will probably use a lot of tweets and the subsequent ones fewer, so I'll be penalised for the first frame. Sep 21 '16 at 9:25
• @PeterTaylor Indeed, that is the point i am ?trying? to make, In the fantasy world where video by tweets is a feature desired by users, having to wait until all the tweets are received before playing the video would be very annoying. So this part of the scoring is to give those solutions that return frames quicker in response to provided tweet(s) an advantage. I am thinking that it may be not that "interesting" or "fun" to have this modifier. I think i shall remove it unless some people think it has some worth. Sep 21 '16 at 11:23
• The point I was trying to make is that the feature of the scoring system seems to me to penalise the approach which you say it's trying to promote. Sep 21 '16 at 11:28
• oh i apologize, i think i misunderstood. Yes, in the example you have given it will penalize that solution, however it would be less penalized than a solution that waited for all tweets, but more penalized than a solution that immediately gives an image frame after each tweet. i.e. the fantasy user would have to wait longer than if the solution produced images after each tweet. Hmm, given the confusion i will remove the modifer as it will be difficult to tune the "negative" effect as to not completely favour immediate frames vs better quality frames. Sep 21 '16 at 11:42

# Interpret MSF-!

Because there aren't enough "Interpret X" challenges.

MiniStringFuck (or MSF-) is a brainfuck derivate made by @ErikTheGolfer, with two commands, operating on one cell:

InstructionAction
+               Increment the memory cell. If it reaches 256, wrap to 0.
.                Output the character in the cell.

or a bad-looking table:

Instruction, Action
+, Increment the memory cell. If it reaches 256, wrap to 0.
., Output the character in the cell.


Your task is to, given a string of MSF- code, containing only printable ASCII characters, output what it would print.

The string may have other characters than + and .. Treat them as NOPs

## Example

++++++++++++++++++++++++++++++++++++++++++++++++.+.+.+.+.+.+.+.+.+.
++++++++++++++++++++++++++++++++++++++++++++++++.                    Set cell to 48 (0) and output
+.+.+.+.+.+.+.+.+.  Keep adding and outputting until 57 (9)


## Test Cases

+++++++++++++++++++++++++++++++++.+.+. -> !"#
++++++++++++++++++++++++++++++++++++++++++++++++.+.+.+.+.+.+.+.+.+. -> 0123456789
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+. -> ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ -> (no output)

• Will the input string ever contain other characters? If so, should they be treated as NOP/comments? Sep 22 '16 at 14:16
• @Geobits Yes and yes. Sep 22 '16 at 15:39
• This is basically "Parse unary numbers", and as such I think it's a duplicate of codegolf.stackexchange.com/q/76756/194 Sep 22 '16 at 16:20

# Interleave your code with the input

Given an input string, interleave this string with the source code of your solution.

For example, if your code is abcd and the input is 1234, then your program must output 1a2b3c4d.

If your code is shorter than the input, then it must loop back to the beginning of your code. For example, if your code is abcd and the input is 123456, then your program must output 1a2b3c4d5a6b.

If your code is longer than the input, then only part of your code will be interleaved with the input. For example, if your code is abcd and the input is 12, then your program must output 1a2b.

### Inputs and outputs

• The input string will only contain characters which are valid string characters in your language.

• The input may be taken through STDIN, as a function argument, or anything similar.

• The output may be printed to STDOUT, returned from a function, or anything similar.

### Scoring

This is , so the shortest answer in bytes wins.

• I'm not even sure that this is possible. Sep 28 '16 at 12:01
• Why would it not be possible? The only potential problem I see is being closed as a dupe for being a straightforward generalised quine. Sep 28 '16 at 12:05
• @PeterTaylor I don't understand how being a "straightforward generalised quine" makes it a dupe (of what?). I don't see how this is more straightforward than say this challenge nor do I think it is a dupe simply because source code is involved. Sep 28 '16 at 12:09
• meta.codegolf.stackexchange.com/a/8595/194 Sep 28 '16 at 13:28