Sandbox for Proposed Challenges

Question

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 requires more feedback, but it's been ignored, you can ask for feedback in The Nineteenth Byte. It's not only allowed, but highly recommended! Be patient and try not to nag people though, you might have to ask multiple times.

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".

Answer 1

Fireworks code-golf ascii-art

---

Make me some fireworks !
And since we are super-late for the 4th make them as quick (read short) as possible !

Input
2 integer, the fuse (any value equal or bigger than 5) and the radius (1 - 2 - 3).

The fuse define the lenght of the tail, the last character of the tail is the center of the explosion. The tail must be centered with the explosion.
The radius define the explosion.

Rule
No need for exception handling, the input will be a valid one.
You may or may not padd your firework, the choice is up to you.
Input, Output and the choice beetwen full program or function is, once again, up To you and your lenguage of choice.
Standard loophole rules apply.
Hopefully no built-in (i'm looking at you mathematica) exist.

Example

fuse 5, radius 1  
     * *    
    * * *
     *|*
      |
      |
      |


fuse 10, radius 3  

   *     *
    *   *
     * *    
* * * * * * *
     *|*
    * | *
   *  |  *
      |
      |
      |
      |
      |
      |

---

while stretching the fuse is not a big deal, ence no limit to it, I found interesting see if it's gonna be cheaper to have hardcoded the strings for the part where the firework cross the fuse or is gonna be cheaper some fancy algorithm, ence I' ve set a limited number of alternative for the radius.

I'm really sorry if my english is bad, I usually can get my idea trought but more than often i stumble with some verbs.

Answer 2

Peter Piper and the Peck of Pickled Peppers

tags: code-golf kolmogorov-complexity

---

Without an introduction, output the following tongue twister:

Peter Piper picked a peck of pickled peppers.
A peck of pickled peppers Peter Piper picked.
If Peter Piper picked a peck of pickled peppers,
Where's the peck of pickled peppers Peter Piper picked?

with or without a trailing newline.

This is code-golf, so shortest code wins.

Answer 3

Transpose a Ragged Array

code-golf

Given an array of arrays of integers where the rows may not be of equal length, pad those rows with nulls, and transpose the array.

Rules

• Use any sane input for the array.
• Specify which null(s) you are using for this function.
• The output should be a transposed array, printed in whatever way is sane for your language.
• This is code golf. Aim for the shortest code possible.

Test cases

I: [[1, 2], [3], [4, 5]]          # Padding with nil here
O: [[1, 3, 4], [2, nil, 5]]

I: [[1], [2, 3], [4, 5]]
O: [[1, 2, 4], [nil, 3, 5]]

I: [[1, 4, 5], [8, 3, 2], [1, 7, 9, 6]]
O: [[1, 8, 1], [4, 3, 7], [5, 2, 9], [nil, nil, 6]]

I: [[1], [2]]
O: [[1, 2]]

I: [[1, 2]]
O: [[1], [2]]

I: [[4, 5, 6, 7], [8, 9]]                  # Padding with spaces here
O: [[4, 8], [5, 9], [6, ' '], [7, ' ']]    # as an example of a different null

As always, if the problem is unclear, please let me know. Good luck and good golfing!

Answer 4

Play a 1D chess variant

in this king-of-the-hill challenge, you must create a bot that plays a 1d chess variant I created, featuring all leaper pieces, and a 15 long board.

Esolangs are encouraged to participate

Game Rules

Goal

To capture the opponents royal (king/queen).

Board

The board is 15 squares long

Player _______________________________ Player
 one   |_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|   two
       player1 side       player2 side

Each player has their side of the board. (note that while playing, you will always be on the left side of the board). You have six squares that belong to you, the opponent has six of their squares, and three squares in the middle are unowned.

Setting up

At the start of the game, you will place your pieces into a configuration of your choice. The pieces will be set independently of each other; this game does not have perfect information. When setting up, you will pick where to place your four pieces, and whether they will be reversed (see next section). You may only place your pieces in your owned squares.

Pieces

There are 4 / 8 pieces; there are 4 distinct pieces, which you can have reversed, and unreversed. I have given them distinct names. Their movements are detailed here.

reversed

reversed means that all the moves of these pieces are reversed in their direction; 2 forward becomes 2 back, three back becomes three forward.

Capture means to move to a space occupied by an enemy piece, and remove that piece from the game. Move means to move to a space occupied by no pieces.

Ascii "diagrams" have been provided. P denotes the piece being showed, $ denotes a space the piece can move to, X a place the piece can capture on, # a piece can move and capture on. Diagrams are the same for both pieces in a pair, because one simply executes the moves backwards.

You must have exactly 4 pieces on the board, and have exactly one from each of the pairs below.

Footman (f)/Coward (c)

The footman may move to an empty space one (1) forward, and capture two (2) forward.

The coward may move to an empty space one (1) backward, and capture two (2) backward.

P$X

Horse (h)/spider (s)

The horse may move to an empty space two (2) or three (3) forward, and move or capture one (1) backward.

The spider may move to an empty space two (2) or three (3) backward, and move or capture one (1) forward.

#P $$

Archer (a)/Trickster (t)

(I doubt anyone will use trickster unironically)

The archer may move two (2) squares backward, one (1) forward, and may capture four (4) steps forward

The trickster may move two (2) squares forward, one (1) backward, and may capture four (4) steps backward

I have included some black and white squares for clarity in distance

# # # #
$ P$  X

King (k)/Queen (q)

Both Royal pieces will end the game when captured.

The king may move or capture one (1) backward

The queen may move or capture one (1) forward

#P

Misc.

Check does not exist: Royal pieces may be left en prise, capture of them results in a win for the capturing side.

There is no (pawn) promotion of any kind

A piece may not attempt to move of the board; the board is a fixed size and does not wrap.

Programs

Programs will take input. When they take input of "0", or a specific input of your choosing, they will output a setup for the game. when they take input "1", or a specific input of your choosing, they will then receive input of the board, and output a move. (the program will be run multiple times)

Moving

To move, you will output the square that the piece is currently on, and the space where you wish to move the piece to, or have the piece capture on. The format is as so (in regex):

[0-9a-e]\n?[0-9a-e]\n?

The board is zero indexed, a piece on the first square is on square 0.

There should be exactly 2 non-newline characters in the output

Input

when it is your turn to move, you will receive input. The input you receive will represent the pieces in the playing field. The input will fit the regex here:

[fFcChHsSaAtTkKqQ ]{15}

Caps represent enemy pieces, lowercase represent your pieces.

when you receive the board positions, you will always have the perspective of player one

WIP, will do more later

Sandbox

What should happen if bots enter an infinite loop? I could just make a draw on a time limit, but that seems not so great, since it is hard for bots to know when they are doing this.

Also just other feedback in general

Answer 5

(-: Emotional Programming ;-)

Write the most emotional program you can, i.e. which consists of emoticons as much as possible.

The program should receive a word and print an appropriate emoticon.

Scoring - I'm really not sure about this, and the question will be worthless without a good scoring algorithm. I want to:
1. Avoid giving an advantage to very short programs (e.g. (-:, is 100% emotional).
2. Avoid a meaningless help of emoticons - print '(-:' #(-:(-:(-: and such.
3. Prefer a variety of different emoticons.

Suggestion:
1. Count characters of code.
2. For each emoticon in the code, reduce a character. 2. For N different emoticons used, reduce further 2*N^2 characters.

What's an emoticon? Anything that somewhat resembles a face, or a closed list?

And should I ban Emoticon?

Answer 6

Create an Autostereogram (Optical Illusion w/ Hidden 3D Shape)

An autostereogram is a type of optical illusion requiring the viewer to, simply put, change distance at which your eyes are trying to view the image. In order to see the hidden image rather than just a nonsensical two-dimensional image, the viewer must either focus their eyes in front of the image (cross-eyed), or behind the image (wall-eyed). Depending on its type, autostereograms may be viewed either way, only cross-eyed, or only wall-eyed. Wall-eyed are the most common.

The illusion below taken from the linked Wikipedia article may only be viewed successfully using the wall-eyed technique. Viewing the full-sized image may help.

The hidden image is:

A shark

I didn't know they were called autostereograms until today, but I always liked this type of optical illusion, since I found the hidden image easy to spot using the wall-eyed technique.

Your goal is to take a depth map and either:

1. Take in an image to modify with the map, then return/display the resulting image
2. Create a random dot autostereogram

The quality of the image must be such that the image is hidden and can be viewed using one of the techniques listed above.

code-golf graphical-output

Answer 7

Generate a Call Tree code-golf graphical-output

Given a C program, generate a graphical call tree.

A call tree is a tree where the nodes represent stack frames, and the connections represent nested function calls. For example, here is a simple C program and its call tree:

#include <stdio.h>

int foo() {
    return 4;
}

int bar(int a) {
    return a + 2;
}

int baz(int a, int b) {
    return a + foo() + bar(a)*bar(b);
}

int main() {
    int a = baz(1, 2);
    printf("%d\n", a);
    return 0;
}

Layout

The layout of a call tree is as follows:

• The top function is always main().
• On the next level below are all of the functions that main calls, in order of calling (top-to-bottom, left-to-right).
• On the next level are all of the functions that those functions call, and so on.
• The leaves of the tree are functions which do not call other functions, or are standard library functions (which are treated as black boxes).
• Each function (with its argument list) is in a rectangle, large enough that the function name and argument list isn't touching the rectangle's borders.
• Rectangles must not touch other rectangles.
• The lines drawn between the rectangles must not touch or cross any line or rectangle other than the two rectangles they are connecting.
• The text must be a monospaced 14-point font.
• The colors of the text, rectangles, lines, and background are not important, so long as all text is one color, all rectangles are one color, all lines are one color, the background is a single color, and everything can be clearly distinguished from the background.

Note that the example image above does not perfectly follow these rules.

Rules

• You may assume that the C program is a valid, standalone program (all functions called are either defined in the input source code or exist in an #included header, and no input is taken from any source).
• Any functions not defined in the input source code are assumed to not call any other functions (this is not the case in reality, but it allows for simplification of the call trees, namely by avoiding implementation-specific details)
• All function calls in the call tree must include the arguments passed.
• main is assumed to not have any arguments.
• There will be no function pointers, gotos, setjmp/jonglmp calls, dynamic memory allocation/deallocation (so no malloc, calloc, realloc or free), or preprocessor macros in the input source code.
• There will be no infinite loops or infinite recursion (all programs are guaranteed to terminate and thus have a finite call tree).
• All arguments will be ints (to simplify matters, since the types don't really matter for this challenge). This means that the example program above would not be a valid input, because of the printf call.
• All functions will either return an int or will be void (non-returning) functions.

Answer 8

Regex Golf Generators

cops-and-robbers kolmogorov-complexity regex

Challenge:

Cops:

The cops must post a 150 byte or less program in any language that outputs between 20 and 200 strings of printable ASCII (this excludes newlines), half of them "match" strings and half "don't match" strings. You can't output an odd number of strings -- there must be one don't match for each match.

The strings can be output as two lists of strings, or one list with a fixed delimiter between the "match" and "don't match" sections. The "match" and "don't match" lists can come in any order.

The following special characters are not allowed in the strings: ()[]*+?.\|^$.

Note that the program must be deterministic, and the language must be revealed.

Robbers:

The robbers must pick a cop answer and submit a regex in any flavor that matches the "match" strings but does not match the "don't match" strings.

The regex must be shorter than min(<length of all the match strings> + <number of match strings>-1 + 4, <length of all the don't match strings> + <number of don't match strings>-1 + 10), as this is the length of the regex that simply hardcodes it: ^(<match string 1>|<match string 2>|...)$ or ^(?!(<don't match string 1>|<don't match string 2>|...)$).*.

The shortest regex posted for that submission wins (note that there can and should be multiple competing cracks for one submission).

Scoring:

The robber's score is simply their number of wins (posted the shortest regex for a given submission) -- higher is better.

The cop's score is max(byte count of winning regex - byte count of submission - 4*(number of match strings - 10) for each submission) -- again, higher is better (you should be maximizing the length of the cracks and minimizing the length of your code). The byte count of the winning regex for an uncracked submission is the length of the hardcoded regex. Self cracks are permitted but must be marked as non-competing and will not count toward your cop or robber score.

The winning cop and robber will be announced 2 weeks after the posting of this challenge. Submissions will be allowed after that, but will not count towards your score.

Answer 9

Machines learning arithmetic

Note: Feel free to take and use this challenge, either the entire challenge as is, or just parts of it.

_{I've made a complete rewrite of this question. I figured the original version was more complex than it had to be. The task is essentially the same. The original challenge text had 4 upvotes and can be found in the edit history.}

---

You will receive 30 lists of integers. Those lists are the result of a polynomial expression y = p(x) = a*x^4 + b*x^3 + c*x^2 + d*x + e, for x in the inclusive range [-1e5, 1e5]. Let's call those lists L1, L2 ....

I reserve the right to make changes to the lists by changing constants and the order if solutions seem to be custom made for those 30 lists.

Challenge:

Your task is to figure out what the constants a, b, c, d, e are for each of those 30 lists.

You will write a code that pulls numbers from each list (one list at a time). It must ask for the y-values for individual x-values, as many as you want, but one at a time. When you think you have enough information, you'll attempt to guess the value of the constants.

You'll do this for all 30 lists.

Scoring:

The lowest score wins!

• You get 1 point for every number you pull from the list
• You get 10 points for every attempt to crack the code (guess a, b, c, d, e)
• The scores for all lists will be added up.

If no submission cracks all lists successfully then the one that cracked the most will win. Tie breaker #1 will be fewest points, tie breaker #2 will be time of submission.

Rules and clarifications:

You can assume all constants to be integers

The lists will be formatted in this way (suppose the expression for L1 is: 2*x). I'm using MATLAB/Octave syntax for a cell array. You can change this to fit your needs (language).

L1 = {[-200000, -199998, -199996, ... -4, -2, 0, 2, 4, ... 199996, 199998, 200000], [0 0 0 2 0]};

You can change the format to fit your needs, but you must not mix the list and the values for a, b, c, d, e.

Example:

You ask for y for four different input values, and get the results:

L1(0) = 0
L1(1) = 0
L1(2) = 2
L1(3) = 12

Your function guesses (for some reason) that this is x^3-2x^2+1, and attempts to crack it:

L1([0, 1, -2, 0, 1]
false

You have tried 4 values, and attempted to crack it once. This gives you 4 + 10 = 14 points.

You try a few more values:

L1(-9) = 6480
L1(-7) = 2352
L1(7)  = 2352
L1(9)  = 6480
L1(100)= 99990000

You're now confident that this has to be: x^4-x^2, and attempt to crack it again:

f([1 0 -1 0 0])
true

You have successfully guessed the constants a, b, c, d, e, and get a score of `14 + (5 + 10) = 29 points.

You have 29 functions left.

---

• I'll have to post the lists on some suitable place (where)?
• Can I ban builtin interpolation functions somehow without risking the "unobservable requirements", "x without y" pitfalls?
• Anything else?

Answer 10

This message is open for anyone to adopt and post to main. For more details, see the chat room or meta post.

Ping an IP address continually and report the dropped to returned ratio

Create a console program that pings an IP address at most once per second and reports the ratio of dropped to returned packets to the screen in real time.

The IP address will be provided on the command line in standard IPv4 notation. (eg. 192.168.0.1)

The 'ping' method should be ICMP echo (See here for a summary of ICMP packet structure) with a packet size of at least 32 bytes.

Your program must be "standalone" and cannot rely on external programs, libraries, or resources.

This is code-golf so let the shortest answer win

Answer 11

Me, Me, Me!

quine code-golf

Edit: changed success when the input matches the source code to when the input is any permutation of the source.

Your code is clearly superior to all other code. In fact, your code is so great that it prints itself when the opportunity arises (but not when any other, inferior code is around.)

Task

Write a program or function that takes a string as input. If the string is equal to some permutation of the characters in your source code, then output the entire source code. Otherwise, output Gross.

If your language uses a non-ascii encoding, "character" is defined as whatever a character in your source looks like. If it's unreasonable to take input in that format, you can treat the bytes of your source as their respective extended ascii codes.

Input

Takes a string using whatever input mechanism your programming language provides.

Output

Prints either the entire source of your program or the word Gross. No additional output is permitted.

Rules

• You can take input using any reasonable method. (Stdin, function parameter, etc.)
• A string a is a permutation of a string b iff each character in the alphabet appears the same number of times in a and b.
• This is code-golf Shortest code (in bytes) wins.

Answer 12

What is your Operating System?

I can't believe we haven't had this one before

To avoid any doubts about what constitutes a separate OS, you must return an index into your chosen subset (containing minimum two) of the following OS families. You may order your set as you like, so include your ordered set, and state if you use zero or one based indexing. You may also bunch together families you cannot distinguish between.

  Windows, Minix, Linux, macOS, BSD, HP-UX, AIX, Solaris, Unix, Z/OS, OS/2, QNX

Your score is your byte count divided by the square of the number of indices your code can return – given that it is run on the appropriate OSs, of course.

You do not have to account for virtual machines, emulation layers etc., e.g. WSL and Wine.

Examples

Your code can detect Windows, macOS, AIX, and Linux. It returns 0 for Windows, 1 for macOS, 2 for AIX, and 3 for Linux. Your score is a sixteenths of your byte count.

Your code can distinguish between Z/OS, OS/2, and UNIX/Linux/AIX. It returns 1 for Z/OS, 2 for OS/2, and 3 for any UNIX-like OS. Your score is a ninth of your byte count.

code-challenge

Answer 13

One OEIS after another

Answer 14

Invisible Ink, Easy code-golf

In the physical world, invisible ink usually becomes invisible when it dries, and is then is readable if it is exposed to heat or chemicals of some kind. The invisible ink in this challenge will be readable when exposed to highlighting.

Create a full program or function that takes in text from the console (using a prompt) and outputs it the console so it cannot be seen unless highlighted.

Notes:

• Assume that the console is a solid color (black, white, green, etc.).

Answer 15

Let's play Othello (Reversi)! king-of-the-hill

Open for takeover

I don't have the time to devote to this right new, and not for the foreseeable future. Anyone who wants this idea, the post, and any code I have in the repo should comment below.

Side note on the code, I have a gorilla repl file in the repo that I can use to run test games on, and get screenshots of during any point of the game. If you want I can make up screenshots for the rules section since I have everything setup on my end for that.

---

This would be a king of the hill about reversi. Yep. I'm going to write up the post and controller later The controller is being written here: https://github.com/JJ-Atkinson/reversi-koth-ppcg , but I'm putting this here so show the idea is taken ;)

---

Post start

Rules

(you can probbably skip this if you've played Reversi before)

(images from http://www.coolmath-games.com/0-reversi)

Reversi is a two player game with a simple goal - own the most pieces on the board.

Wikipedia

Answer 16

Prime encode integers!

code-golf

In this challenge, you must convert inputted natural numbers into a prime encoding.

The sequence of the primes, and 1, is a complete sequence (We're going to consider 1 an honourary prime for this challenge). What this means is that it's possible to express any positive integer as a sum of the terms of the sequence (without reusing terms). For example, the powers of two are a complete sequence, and you can encode numbers in them (this is binary).

As with binary, you use a sequence of 1s and 0s to represent which terms are used. 1011 will represent 5 + 1 + 2, or 8. 8 could also be represented as 10001, or 7+1. the place values represent primes:

... 13 11 7 5 3 2 1

continuing with all of the primes to the left

In this challenge, you must output a string of 1s and 0s, such that the place value primes sum to inputted strictly positive integer

Test cases

8 -> 10001 or 1011
2 -> 10
11 -> 1111 or 10101 or 100000 (I might have missed one of the possibilities?)
13 -> 1000000 or any other possibility

you may use any valid representation of the in

input note:

input is 1 strictly positive integer

you do not need to consider the value 0, even though it is possible to represent in this system, by just outputting zero

Answer 17

Find the longest Factor-Multiple sequence

Inspired by this riddle.

A Factor-Multiple sequence is any sequence where A[n+1] is either a multiple or factor of A[n].

Task

Create a full program or function that, given a list (or any other accepted input) of positive integers, returns (one of the) the longest possible Factor-Multiple sequence containing those numbers. Each number can only be used once and each number in the input will be unique.

Input

As mentioned above, input is a list of integers. If your language only supports strings, or if you like doing so, you may take input as strings instead.

Output

You can output your sequence in any way you like as defined on meta.

Rules

• This is codegolf, shortest code wins.

Test cases

More need to be added.

Input                                                Output                 
1 2 3 5 7 11                                         2 1 3 or 3 1 2 or 11 1 7 etc.
1 2 3 4 5 6 7 8 9 10                                 5 10 1 4 8 2 6 3 9  

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20   11  1  7 14  2  8 16  4 12  6 18  9  3 15  5 10 20 

Meta:

• Need to add more test-cases

• Can't think of any relevant rules, did I miss any?

Answer 18

I'm symmetric, not palindromic! code-golf string

Background

Inspired by I'm a palindrome. Are you?, where it is presented the shocking fact that “()() is not a palindrome, but ())(”, I asked myself what instead is ()() and the answer is simply: it is a string with a vertical symmetry axis!

The task

Write a program or function that takes a string S (or the appropriate equivalent in your language) as input, checks for symmetry along the vertical axis, and returns a truthy or falsy value accordingly. You can use any reasonable means to take the input and provide the output.

Reflectional symmetry

Reflectional symmetry around a vertical axis (or left-right symmetry) means that if you put a mirror vertically at the exact center of the string, the reflected image of the first half of the string is identical to the second half of the string.

For example, the following strings are reflectional symmetric around a vertical axis:

()()
()()()
[A + A]
WOW ! WOW
OH-AH_wx'xw_HA-HO
(<<[[[T*T]]]>>)
(:)
)-(
())(()
qpqp

while the following are not:

())(
((B))
11
+-*+-
WOW ! wow
(;)
qppq

Rules of the contest

• Your program or function will receive only printable ASCII characters. You can include or not the empty string, (which is symmetric, of course!) as legal input, which is better for you.

• The ASCII characters that can be considered symmetric with respect to the vertical axes are the following (note the initial space, and the difference between uppercase and lowercase letters):

 !"'+*-.:=AHIMOTUVWXY^_ovwx|

The ASCII characters that can be considered “mirrored” and their corresponding characters are:

()<>[]{}qpbd/\

Note that, since they are mirrored, you can have both () as well as )(, /\ and \/, etc.

All the other ASCII printable characters must be considered asymmetric and without a mirrored corresponding character.

• This is a code-golf challenge: the shorter your program is, measured in bytes, the better, in any programming language.

• Kudos to people that will produce a symmetric program!

Answer 19

Simulate Alpha Decay

Answer 20

Zoom box drawing characters

Here are some sample box drawing characters:

  ╷
 ┌┴┐
╶┤ ├╴
 └┬┘
  ╵

How do we zoom them? Well, we need to triple their size. The result looks like this:

      ╻
      ┃
      ┃
   ┏━━┻━━┓
   ┃     ┃
   ┃     ┃
╺━━┫     ┣━━╸
   ┃     ┃
   ┃     ┃
   ┗━━┳━━┛
      ┃
      ┃
      ╹

As you can see, what happens is this:

• Each box drawing character is replaced by its heavy version (for extra thickness)
• The box drawing characters are extended using the heavy horizontal and heavy vertical characters, resulting in a separation of three between the original characters

You can use any reasonable character I/O format. You will only need to support spaces and the 15 basic box drawing characters, plus newlines if you need them as line separators. You can only require rectangular input, but your output may contain arbitrary whitespace padding, except on the left, so that the characters in the zoomed image are aligned.

This is code-golf, so the shortest solution in bytes that violates no standard loopholes wins, but if you're using UTF-8 encoding then you can score all box drawing characters as 1 each.

Answer 21

Does it have a square? (simple version) code-golf matrix

Given a matrix of 0s and 1s, determine if there are 4 points that are 1 and are the corners of a square.

Here's an example to clarify, with a possible square (in bold):

0 0 0 0 0 0 0 1
0 0 0 1 0 1 0 0
0 0 0 0 1 1 0 0
0 0 0 1 0 1 0 0
1 0 0 0 0 0 0 1
0 1 1 0 0 1 1 1
1 1 1 1 1 0 0 1
0 1 0 0 1 0 1 1
1 1 1 1 0 0 1 0
1 0 0 1 0 1 0 1
0 0 1 0 1 0 1 1
1 0 0 1 1 0 1 1

Another possible square is the following:

0 0 0 0 0 0 0 1
0 0 0 1 0 1 0 0
0 0 0 0 1 1 0 0
0 0 0 1 0 1 0 0
1 0 0 0 0 0 0 1
0 1 1 0 0 1 1 1
1 1 1 1 1 0 0 1
0 1 0 0 1 0 1 1
1 1 1 1 0 0 1 0
1 0 0 1 0 1 0 1
0 0 1 0 1 0 1 1
1 0 0 1 1 0 1 1

There are many squares in this matrix, but the point isn't to count the squares, just to determine if there's a square in it. Since there is a square in it, your solution, given this matrix, must return a truthy value.

Given this matrix, your solution must return a falsy value:

0 0 0 0 0 0
0 1 1 0 0 1
0 1 0 0 1 1
0 1 1 0 1 0

You can see there's no square in there.

Rules

• Since the input is a matrix, it will always be rectangular.
• Probably needless to say, the sides of a square must be equal.
• The corners of a square must all be 1.
• A square must have at least side length 2 to be considered a square, otherwise this challenge would be extremely trivial.
• Standard Loopholes, as usual, are forbidden.

Test cases

This section is under construction.

Answer 22

LaTeX truth tables

Write a program or a function that accepts the list of outputs from a logic function and outputs the LaTeX code for its truth table.

The inputs should be labeled as lowercase letters a-z, and the output should be labelled as F. The length of list of inputs will always be shorter than 2^25, which means that number of inputs will always be less than 25, so you can use letters from lowercase alphabet for input names.

Input

A number n of inputs and list of length 2^n of binary numbers which represents the outputs of a logical function.

Output

LaTeX code that produces the truth table for that function. Input and output values should be centered in rows. There must be a line between table header and its values and between inputs and output, so the code should be similar to that below.

\begin{tabular}{c * <NUMBER OF INPUTS>|c}
<INPUTS>&F\\
\hline
<INPUT VECTOR i>&<OUTPUT>\\
\end{tabular}

Example

Input:

2
[0, 0, 0, 1]

Output:

\begin{tabular}{cc|c}
a & b & F \\
\hline
0 & 0 & 0 \\
0 & 1 & 0 \\
1 & 0 & 0 \\
1 & 1 & 1 \\
\end{tabular}

Which when displayed in LaTeX shows the following truth table

General rules

• This is code-golf, so shortest answer in bytes wins.
• Default Loopholes are forbidden.

Answer 23

Insert Random Squares Here

graphical-outputrandomcode-golf

---

^{Related challenges.}

< Insert sales pitch here >

The Challenge

Given a width and a height, output an image filled with random squares.

Input

Your program/function is given a width and a height in pixels.

E.g.:

yourProgram <width> <height>

Output

You must display the result on the screen, or output an image file in any acceptable format.

Rules

• The number of squares to be generated is a random natural number between sqrt(w * h) / 2 and sqrt(w * h) * 2 (inclusive).
• Each square's color will be randomly generated for each with R, G, B ranging from 0-255 and with alpha values ranging from 1-255.
• Each square's width/height will be a random value between 1 and min(w, h) (inclusive)
• Each square must be placed randomly. Part of the square may be outside the output image, as long as at least one pixel of the square is visible.
  • Placement at sub-pixel coordinates (e.g. x=0.239420, y=2.8298329) is allowed but not required.
• Each possible output must be equally likely to occur.
• The output must have a white or transparent background.

Example

Input and randomly generated parameters

Width: 10
Height: 20

Maximum square height: 10

Minimum number of squares: 8 Math.sqrt(10*20)/2 = 7.0710678118654755
Maximum number of squares: 28 Math.sqrt(10*20)*2 = 28.284271247461902

Number of squares  in this example: 8

Output

Scaled 2000%:

Output with the parts of the squares that are off-screen

(Scaled 2000%.) The gray part is the part that is displayed on the screen.

Answer 24

A Fine-Grained Mesh

code-golf

If you've used Matlab before, it's highly likely that you've heard of meshgrid. It's a function that has since mostly been obsoleted by broadcasting, but it still has its uses sometimes.

The function itself is relatively simple. Given two vectors x and y of length m and n, create two 2-dimensional matrices X and Y both with m columns and n rows such that:

1. Any row of X is a copy of x
2. Any column of Y is a copy of y

But typing out meshgrid(x,y) takes so long, you know? I'd like to be more efficient with my coding. Your job is to reimplement this function in the fewest bytes possible.

Standard loopholes disallowed.

Answer 25

Flit - a simple board game for bots

king-of-the-hill

---

I've made a human playable version of this game with a simple strategy to give an idea of how the game plays out. You can play it before or after reading the rules here - picking up the rules intuitively adds an extra challenge...

If playing this gives any idea about whether the KotH version would be better with 2, 4, or more players per game, or any other subtle adjustments that would help, please let me know.

---

Note: adjacency is vertical or horizontal - for this game there are no diagonal neighbours.

Overview

The board is a square grid. Each bot starts with 2 pieces of their colour, and gains more pieces by converting neutral pieces that appear from time to time. The objective is to end up with more pieces than your opponents.

Each turn, one bot moves. It chooses one of its pieces and moves it to be next to another of its pieces. There is no limit to the distance a piece can move in a single step, provided it lands next to a piece of the same colour.

Neutral pieces

There are initially zero neutral pieces.

A new neutral piece can appear at any time, regardless of whether there are already neutral pieces unconverted. A neutral piece will only appear on an empty square that has 4 empty neighbours, to prevent it being instantly converted.

If a neutral piece is adjacent to another piece, it is converted - it becomes the colour of that piece. A neutral piece can only ever be adjacent to a single other piece - it will be instantly converted before any other bot has a chance to move next to it.

Moving

A move is specified by an origin square and a destination square. It is a valid move if the origin square contains a piece of the bot's colour, and the destination square is empty and is adjacent to at least one piece of the bot's colour. Note that the piece being moved cannot also be the piece adjacent to the destination square (a piece cannot simply move next to its own previous position). Two distinct pieces are required - one to be moved, and one to be adjacent to the destination.

[Not moving is a valid move, and is indicated by specifying the same coordinates for origin square and destination square. not sure about this rule] Not supplying a move within the time limit also results in not moving, but repeatedly exceeding the time limit will lead to the bot losing the opportunity to make further moves.

Communication

The board information will not be supplied each turn. Instead the bot must keep track of the board state itself. Each time a change is made a message will be sent to all bots describing the change. If a bot chooses not to move, the non-move will not be broadcast.

The board starts empty. The initial two pieces for each bot will be broadcast to all bots, then the first bot will be sent a request for a move, to which it must respond within the time limit. Any response sent after the time limit expires will be discarded (any waiting input will be read and discarded before the next request for a move is sent to that bot).

Bots will therefore have complete information about the board state at all times.

Specification

Available: An available square is an empty square that has 4 empty neighbours

Players

There are 4 bots competing in each game. Bots are numbered 1 to 4 and take turns in that fixed order.

Board

The board is a 32 by 32 square grid. It wraps toroidally - every square has 4 neighbours. The board has no boundaries - no edges or corners to give an advantage.

Initial state

For each bot, one piece will be placed on a square chosen uniformly from the available squares. After all first pieces have been placed, a second piece will be placed for each bot in the same way. The initial state contains no neutral pieces.

Addition of neutral pieces

Each turn one bot will move. After that move has been made, the addition of a new neutral piece will be considered. A square will be selected at random. If that square is available then a neutral piece will be placed on it with probability 1/16. If the square is unavailable then play continues - a second square will not be selected. [This differs from the human playable version linked above: there a list is kept of all available squares and a neutral piece is placed on one of those with probability 1/6 each turn - I now prefer this approach so the rate of new neutral pieces does not slow in the end game]

Bot STDIN

All received messages will be terminated by a newline. Each bot will receive messages of two types: an update or a move request

Update:

x y c

where (x, y) is the square to be updated, and c is the new colour (which may be 0 for empty, 1, 2, 3 or 4 for a bot colour, or 5 for neutral).

Move request:

M

where M is the literal string "M" and indicates that a move is required.

Bot STDOUT

The response must be terminated by a newline. A bot responds with a move in the following format:

x0 y0 x1 y1

where (x0, y0) is the origin square, and (x1, y1) is the destination square.

If origin and destination are identical, no move will be made. This is valid and does not lead to the bot being penalised. The bot will only be penalised if it fails to respond within the time limit.

Time limit

The time limit is 50ms. If a bot exceeds the time limit on 5 consecutive turns then it will no longer be prompted for moves. That bot will be frozen for the rest of the game.

Winning criterion

The winner is the bot with the most pieces when the game ends. There is no reward for second place. If two bots tie for first place, neither is rewarded.

The game ends when one of the following conditions is met:

• the total number of turns taken exceeds 32,768 (8,192 per bot)
• all 4 bots choose not to move consecutively
• one bot has too many pieces to catch up with

Too many pieces to catch up with is defined as follows:

• A, B and C are the numbers of pieces of the other 3 bots.
• D is the number of pieces of the bot in question.
• N is the number of neutral pieces.
• E is the number of empty squares.
• P is the number of potential neutral pieces. P = N + E - 4
• M is the maximum number of pieces attainable by A, B or C.
• M = Max(A+P, B+P, C+P)
• If D > M then the bot has too many pieces to catch up with.

I've tried to make this game as simple as possible, while still having non-trivial dynamics.

Answer 26

Musical Washing Machine

I have a washing machine with a knob and several buttons. The knob selects the type of laundry and the buttons cycle through water temperature, etc. options. When pressed, these each create a musical note. There are five musical notes that can be made, in this ascending order: F A C D E

knob (K)
   When 360ed: play D and reset all other buttons
wash temp (T)
   1st press (cool -> warm): A
   2nd press (warm -> hot): F
   3rd press (hot -> cold): E
   4th press (cold -> cool): C
   (repeat)
spin speed (S)
   1st press (medium -> max extract): F
   2nd press (max extract -> no spin): E
   3rd press (no spin -> medium): A
   (repeat)
soil level (L)
   1st press (medium -> heavy): A
   2nd press (heavy -> extra heavy): F
   3rd press (extra heavy -> light): E
   4th press (light -> medium): C
   (repeat)

The Challenge

Given a series of notes, determine if if can be played on my washing machine, and, if so, output the series of moves to generate it.

I/O coming soon to a washing machine near you

Answer 27

Make a Sierpinski triangle

Your challenge is to output a n-th order right-angle Sierpinski triangle, similar to this (third-order):

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

Input:

A number, n, and a character (in this example '#');

Output:

A 2**n (two to the n) line Sierpinski triangle, made of the given character. You could consider it a two-state cellular automaton: the cells are separated by a single spaaace; if it is on, it contains the given character; Otherwise is contains a spaaace.

Examples:

in:

0 *

out:

*

explanation:

2**0=1

in:

1 *

out:

*
* *

in:

2 *

out:

*
* *
*   *
* * * *

Winner:

this is codegolf so the winner is the answer with the least bytes. (NOTE: might add something tho do with triangles of the same character.)

Hint:

it might be helpful to know that the n-th line contains the previous line xor that line shifted right by one cell (x^(x>>1)).

Answer 28

-(-(--x)--))> Code Kebabs! <-(-(--x)--))

---

Your goal is to parse Code Kebabs, they look like this:

-x--> 8
2 <-(-(--x)--))
-x-x-x--> -10
--x> 255

A Code Kebab is made up of 3 parts, the stick, the tip (< and >), and the stand (the number compared by)

stick tip stand 
--x-- >   -5

The stick

---

The stick contains 4 operators, and the variable (x) The operators are listed here, in order of precedence:

1. ( ... ) | Brackets. They are the "veggies" on a code kebab. Everything inside them runs before the rest of the kebab, with the last, deepest pair going first. Brackets can be nested.

2. v-- | Suffix decrementation. This is one of the 4 parts of the stick, and decrements the value supplied to it by one.

3. v-v | Subtraction. This is the 2nd part of the stick, and subtracts the two values.

4. --x | Prefix decrementation. This is the 3rd part of the stick, and decrements the value supplied to it by one.

5. -v | Negation. This is the 4th and final part of the stick, and inverts the value supplied.

Each operator returns it's result, and can be used as input for other operators.

The Tip

---

The tip is one of two symbols: < or > When the tip is <, the stand must be left of it, with the tip being left of the stick. When it is >, the stand is to it's right, with the tip being on the right of the stick.

The Stand

---

The stand is any integer. That's all there really is to say about it.

Execution of the kebab

---

You can't execute a kebab without eating it!

Kebabs are executed in a loop until their condition (The result of the stick being less than the stand's value) is fulfilled. When execution is finished, the variable (x) is set to the result of the stick, X is printed, and execution resumes again unless the condition is fulfilled.

When execution starts for the first time, X is set to 10 beforehand.

TODO

---

• Add test cases.

• Clear a few things up.

• Make the description of execution a bit clearer?

Answer 29

Nearest neighbors in a square lattice

code-golf sequence square-lattice

Premise

Consider an infinite 2D square lattice. We can choose one point as the origin and label each point with a pair of integers that corresponds to points on the Euclidean plane:

Now consider the point at the origin, \$(0,0)\$. The set of lattice points closes to the origin (but not including the origin) is \$\{(1,0),(0,1),(-1,0),(0,-1)\}\$. We will call this set the \$1\$st nearest neighbors. The set of lattice points closest to the origin but not including the \$1\$st nearest neighbors is \$\{(1,1),(-1,1),(-1,-1),(1,-1)\}\$. We call this set the \$2\$nd nearest neighbors

Now we can define the \$k\$-th nearest neighbors as the set of points closest to the origin and not included in the union of the set of \$n\$-th nearest neighbors for \$n\in\{1,2,...k-1\}\$.

Define the sequence \$NN(k)\$ as the length of the set of \$k\$-th nearest neighbors.

Task

Given \$k\$, compute \$NN(k)\$. This is A105352 on OEIS without the first element.

Rules

• You may use 0- or 1- based indexing.
• Given \$k\$, you may either output the first \$k\$ elements of the sequence or the \$k\$-th element.
• You may alternatively take no input and output the sequence indefinitely.
• Standard loopholes disallowed.

Here are some 1-indexed test cases:

n   NN(k)
1   4
8   8
9   4
10  8
38  16
52  8
80  8
121 24
145 12

Answer 30

Breaking into 3 Palindromes:

As discussed here and here, every positive integer can be written as the sum of 3 palindrome integers. Given a number "n", output these integers.

Challenge

• This is a code golf challenge. The shortest functional solution wins.
• The input number "n" will be any integer greater than 0 but less than 1,000,000,000.
• The three output numbers must be palindromes. Their sum must be "n".
• A palindrome number is a number which is the same forwards as backwards. It can have any number of digits.
• To make this easier, I will allow positive or negative palindrome integers.
• Output and input can be formatted in any what that is convenient as long as it can be readily understood.

Examples

input: 5
output: 0,0,5

input: 1234
output: 1001,222,11

input: 3141592
output: 2200022,926629,14941