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

Group binary shapes together

Answer 2

Two inverse quines

Your challenge is to write two programs A and B such that:

• A outputs B
• B outputs A
• Wherever there is a space character in A, there is a non-whitespace character in B, and vice versa (newlines must be consistent through both)
• This means A and B are the same length in characters.

For example A and B are valid, but A and B are not.

Newlines must be consistent through both, so A \nB and C\n D are valid, but A C and B\nD are not.

Scoring

Your score is the length in bytes of either of your programs. If they're different lengths in bytes, take the average.

Answer 3

Knapsack Paragraph, Format For A Phone

There are several paragraph formatting questions already on the site, where a string of text is split on space or other boundaries in order to fit into a rectangle; but they usually involve specifying a particular width for the formatted paragraph in addition to the supplied text.

For this problem, instead of a fixed width, we want to minimize the perimeter of the bounding box of the formatted text. Because we are developers for a phone app and we have to pay for the border by the inch. Or some other such tom-foolery; actually I noticed that this is a bit of a knapsack problem, and I just like the resemblance to that old folk song "knick-knack paddywack, give a dog a bone".

Challenge

Define a layout of a string T of text as a list of n strings s[i] such that the joined string using spaces as delimiter, i.e. s[0]+' '+s[1]+' '+...+' '+s[n-1] is equal to T.

The semiperimeter of a layout s is n plus the maximum length of any s[i] in s.

Given as input a string T, your submission must output the minimum semiperimeter across all valid layouts of T. Alternatively, you may output a layout which has a semiperimeter which is minimal.

The restrictions on input are forgiving; in particular, you may take T as a list of words (strings without spaces) instead of a single string; so long as the result includes the count of spaces that would be present in the layout when calculating the semiperimeter.

This is code-golf; so the shortest submission in each language is the winner, and will be honored with a parade at some vague time in the near future.

Notes:

Just wanted to get this down; will edit later. Mulling whether to have output be the integer, or an example layout having the minimal perimeter. The former is simpler to construct; but the latter just seems more satisfying as an output.

Answer 4

The Roly-Poly, Square-Wheeled Quine

Moved here. Thank you for the comments.

Answer 5

Your challenge is to write a method that compresses/decompresses strings. It will get two arguments: any string (with any ASCII characters) to compress/decompress, and a boolean. If the boolean is true, compress, else decompress.

It can either print the output to stdout or return the data.

The twist is that your score is equal to the byte count of your source code + the byte count of your source code compressed by the compressor. So if your code was c=>c (which is invalid btw), your score would be 4 + 4 = 8.

Rules

• Standard loopholes not allowed

• The decompression and compression should work.

• Your code should not just return the same data. So this

  c=>c
  

  is invalid

Test function to check the score

If you like, here's a function which checks your (javascript) answer.

function checkCompressor(compressor) {
    const source = compressor.toString();
    const compressed = compressor(source, true);
    const decompressed = compressor(compressed, false);
    if (source !== decompressed) return false;
    return compressed; // Have to get byte count manually
}

Answer 6

Determine the length of a Puyo Puyo chain

Puyo Puyo is a Japanese tile-matching puzzle game currently developed by Sega. The gameplay seems simple but it is actually quite complex.

You have a 12x6 board which you can fill with various colors (typically red, green, blue, yellow, and purple) of Puyo (round slime-like creatures with eyes). Each turn, you control a pair of Puyo that you can manipulate and place on the board not unlike Tetris.

When a pair is placed, gravity is applied to the board. If there is an empty gap underneath one or more Puyo in a column, they fall to fill the gap.

When two Puyo of the same color are adjacent to each other, they link together. When 4 or more Puyo are linked, they pop (disappear). After a group of Puyo pops, if gravity causes another group to pop, then you have created a chain. The goal of Puyo Puyo is to place Puyo so that you create as long of a chain as possible to overwhelm your opponent with nuisance Puyo.

Nuisance Puyo are a special case - they are colorless (usually gray or transparent), but more importantly they do not link together. Instead, they pop when an adjacent colored Puyo pops.

Challenge

Given a Puyo Puyo board in any reasonable format (12 lines of 6 character strings, a 12x6 matrix of characters/numbers, 12 6-character strings in an array, etc.) output the chain length as a number. Standard loopholes apply.

This is code-golf, so shortest source code wins.

Bonus: In Puyo Puyo Tsuu, a hidden 13th row was added above the playfield to allow for longer chains. You will get a -5% score bonus if your program can optionally accept a 13th row.

Test cases

Note: Intermediate board states are shown to demonstrate the game mechanics; you are not required to output them.

Key: Red, Green, Blue, Yellow, Purple, Nuisance, . empty

Output: 4

...... ...... ...... ...... ......
...... ...... ...... ...... ......
...... ...... ...... ...... ......
...... ...... ...... ...... ......
......>......>......>......>......
...... ...... ...... ...... ......
...... ...... ...... ...... ......
...... ...... ...... ...... ......
..GBR. ...BR. ....R. ...... ......
..RGBR ...GBR ....BR .....R ......
..RGBR ...GBR ....BR .....R ......
.RRGBR ..GGBR ...BBR ....RR ......

Output: 4

...... ...... ...... ...... ......
...... ...... ...... ...... ......
...... ...... ...... ...... ......
...... ...... ...... ...... ......
......>......>......>......>......
.G.... ...... ...... ...... ......
YG.... ...... ...... ...... ......
NGY... ..Y... ..Y... ...... ......
NGR... Y.R... ..R... ..Y... ......
YBR... YBR... ..R... ..R... ......
YYBR.. YYBR.. .BBR.. ..RR.. ......
BBRR.. BBRR.. BBRR.. ..RR.. ..Y...

Output: 0

......
......
......
......
......
......
......
......
.B....
BR....
BR....
BR....

Output: 19 (requires bonus; sorry, no intermediate states)

..YRYY
GBBYRG
RBYRYY
GBYRYG
RYRGBG
YRGBYG
RYRGBY
RYRGBY
RGGBGB
GBYRBB
RGBYRG
RGBYRG
RGBYRG

The Puyo Nexus chain simulator might be useful while debugging.

Answer 7

Reverse cadaddadadaddddaddddddr

The Lisp language has a family of functions car, cdr, cadr, etc for accessing arrays. For each one, an a defines taking the first item of an array, and a d defines taking the rest.

For example, running cadr on [[1,3,4],5,7] will return [3,4] as the a gets the first item ([1,3,4]) and the d removes the first item.

We've already had a challenge regarding running a cadaddadadaddddaddddddr on a list, but what about the reverse?

Your challenge is to, given a string of the type above (starting with a c, ending with a r, with only ad in the middle), and a single value, create an array such that running the string as a cadaddadadaddddaddddddr on the array returns said value.

For example, given the input cadar, 1 a possible output could be [[0,[1]]] since running cadar on that gives 1.

Scoring

This is code-golf, shortest wins!

Testcases

These are possible outputs, all that matters is that your program returns an array which works for the condition.

car, 3 => [3]
cdddar, 5 => [0,0,0,5]
cadadadadar, 4 => [[0,[0,[0,[0,[4]]]]]]
caaaaaaaaar, 2 => [[[[[[[[[[2]]]]]]]]]]

Let me know if any of these are wrong.

Answer 8

Convince me that this vector theorem is true

code-golfmathlinear-algebra

Background Information

From Wikipedia:

A sequence of vectors \$\mathbf v_1,\mathbf v_2,\mathbf v_3,\dots,\mathbf v_k\$ from a vector space \$V\$ is said to be linearly dependent, if there exists scalars \$a_1,a_2,\dots,a_k\$ such that: $$a_1\mathbf v_1+a_2\mathbf v_2+\cdots+a_k\mathbf v_k=\mathbf 0$$ where \$\mathbf 0\$ denotes the zero vector.

Based on many sources¹ around the internet, it is true that

If there are more vectors than dimensions, the vectors are linearly dependent.

In other words, if the vector space is \$\mathbb R^n\$(the number of entries in each vector is \$n\$), then the sequence of vectors \$\mathbf v_1,\mathbf v_2,\dots,\mathbf v_p\$ is always linearly dependent if \$p>n\ge2\$.

Task

After looking around, I'm still not entirely convinced that the above statement is true. Please convince me with a program that takes in: the dimension \$n\$(you don't have to take this in if you don't need to), and \$p\$ \$n\$-dimensional vectors \$\mathbf v_1,\mathbf v_2,\dots,\mathbf v_p\$, where \$p>n\ge2\$. You can take in \$p\$ in your program if you want to. You can assume that all vector entries in each vector are integer values. The input format can be whatever you choose, as long as there is a clear distinction between each vector. The program should return a list of scalars \$a_1,a_2,\dots,a_p\$, with at least one of them non-zero, such that $$a_1\mathbf v_1+a_2\mathbf v_2+\cdots+a_p\mathbf v_p=\mathbf 0$$ to show linear dependency. If there are multiple outputs that work, you can output any one of them. The output format is also flexible, as long as it is clear what the values of each scalar are.

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

Example I/O

Input:
\$n=2\$
\$p=3\$
\$\mathbf v_1,\mathbf v_2,\dots,\mathbf v_p=\pmatrix{4\\5},\pmatrix{8\\10},\pmatrix{6\\7}\$

Output:
One possible solution is \$a_1,a_2,\dots,a_p=2,-1,0\$. We can quickly test that this does work: $$2\pmatrix{4\\5}+(-1)\pmatrix{8\\10}+0\pmatrix{6\\7}=\pmatrix{8\\10}-\pmatrix{8\\10}+\pmatrix{0\\0}=\pmatrix{0\\0}=\mathbf 0$$

Test Cases:

Work in progress

n, vectors -> scalars
2, [(4,5),(8,10),(6,7)] -> [2,-1,0]
2, [(3,6),(6,7),(3,9),(2,4),(5,5)] -> [2,0,0,-3,0]
3, [(1,2,3),(2,3,4),(3,4,5),(4,5,6),(5,6,7),(6,7,8),(7,8,9),(8,9,10)] -> [1,-1,-1,1,1,-1,-1,1]

---

¹: Some sources: this, this, this, this

---

Concerns

• Has a similar challenge been done before?
• Is it clear what the challenge is specifying?
• I want to change the title to be more specific, but I'm not sure what to change it to.
• I need some test cases, but I'm not sure what test cases would be good for this.

Answer 9

All valid N * N Flow Free Boards.

Since there are several other Flow Free question, either here or on main, but none, as far as I can tell, that do this, I will ask the question some of us have pondered at night: How many valid Flow Free Boards are there?

What is a valid board?

From what I can tell from my attempts at time trial, a valid board has all of these:

1. Has between floor(2N/3) and ceil(3N/2) flows (where a flow is two distinct points, defined as it's ends, between which a line can be drawn connecting them).

2. No two endpoints of a flow can be adjacent.

3. The board must be solvable - that is, there must be a way that all endpoints of the flows can be connected together such that every square of the board is filled once and only once, and no two paths intersect at all.

Input/Output

Your program will receive N, the side length of the board. The board will always be square (as that is the case in most boards), and it must return all valid boards, and the number of such boards.

As always, you can take input and output in any reasonable format, and shortest byte count wins!

Meta

Has this been done before?

Anything that needs specifying?

Answer 10

Who Won Tic-Tac-Toe?

Your job is to be the judge of a game of Tic-Tac-Toe.

Given an input consisting of three lines (9 characters not including newlines), determine the winner of the game of Tic-Tac-Toe.

For example, for the input

XOO
-XO
O-X

your program should either return or print X.

For tie games or games where no one has won, do not print or return anything.

The only input characters will be 'X', 'O', and '-' (along with two newlines), and the only outputs your program should give are 'X' and 'O' (or nothing).

Also note that the given board will be a valid game of Tic-Tac-Toe, so there will be no situations where both players have winning positions.

More examples:

OOO
---
---

=> O

OXO
--X
---

=> (nothing)

OXO
X-O
X-O

=> O

OXO
XOX
XOX

=> (nothing)

Answer 11

Tic-Tac Clock

given a time of the day (0-12 inclusive) output the closest fitting clock. This means 0/12, 3, 6 and 9 should be straight up/to the side. The one's in between go in the corners!

The clock should look as follows:

      #|#
0  -> #+#
      ###

      ##/
1  -> #+#
      ###

      ##/
2  -> #+#
      ###

      ###
3  -> #+-
      ###

      ###
4  -> #+#
      ##\

      ###
5  -> #+#
      ##\

      ###
6  -> #+#
      #|#

      ###
7  -> #+#
      /##

      ###
8  -> #+#
      /##

      ###
9  -> -+#
      ###

      \##
10 -> #+#
      ###

      \##
11 -> #+#
      ###

      #|#
12 -> #+#
      ###

This is code-golf so the shortest answer (per language) in bytes wins.

questions

This is my first question so I'd appreciate some feedback, mainly if this challenge would be too tedious to do.

Answer 12

Add 2 numbers using a graphics card

Introduction

Graphics cards have great performance when doing big calculations. So lets make a small calculation

Challenge

• Inputs: 2 floats of choice

• output: the addition of the two floats.

• The addition should be calculated on the graphics card, but it doesn't matter if it doesn't work on all gpu's

• Lowest score in bytes wins

Example Input and Output

2.5 and 3.2 -> 5.7

Answer 13

Implement the LC-3 VM [1] using 16-bit subneg4 [2] only & test it

Answer 14

What will the radio play next week?

Each week, Billboard publishes the US music industry standard ranking of the 100 most popular songs based on sales, radio play, and online streaming. The current chart can be found here.

For each song on the chart, Billboard reports the song's current ranking (from 1 to 100, with 1 being the best), the previous week's ranking of that song (labeled "last week"), the best ranking that the song has ever received by Billboard (labeled "peak"), and the number of weeks that the song has appeared on Billboard charts to date (labeled "wks on chart").

Pop stations in the US generally play the top 40 most popular songs on a given week. In this challenge, we will predict what the radio will play next week given previous Billboard charts.

The Data

This text file provides the "last week" data for every chart from July 25, 2015 though July 17, 2021 (based on data provided here). There are 313 lines (one for each week) with 100 comma-separated numbers in each line. The first line corresponds to July 25, 2015, and on that week's chart, "Cheerleader" by OMI was ranked #1 (up from #2 the previous week), while Chris Young's "I'm Comin' Over" made its debut on the chart at #100. In the first line of the data provided, this is reflected with the first entry being 2 and the last entry being 101 (throughout, 101 indicates that the song did not chart on the previous week). The next line of the data starts with a 1, indicating that OMI's "Cheerleader" was still ranked #1 on the August 1, 2015 chart. In this way, the data captures how songs move up and down the chart from week to week.

The Challenge

Write a program or function that, for each n from 0 to 312, receives the first n lines of the data as input and outputs the first 40 numbers from line n+1.

Standard code-golf rules apply. The shortest code in bytes wins.

code-golfkolmogorov-complexitycompression

Answer 15

Binary integer subtraction a - b with 0 < b < a using string processing logic code-golf subtraction integer string

My Work

I noticed that for this subtraction problem it is not necessary to use twos-complement and that the result can be stored in the same memory required to store a; all that is required is to employ symbolic/logic processing on bit/char-strings.

I wrote a Python program that uses divmod, but that was just a way of 'shifting-off' the right most bit from the bitstring, so the code-golf answers should not use any arithmetical operations.

Here is my program, which can be taken to solve an implicit string processing specification:

minuend =    int(10**1111)
subtrahend = int(10**1110)

if True: #debugging
    minuend =    0b110101
    subtrahend = 0b000111
    M = minuend
    S = subtrahend

difference = ''
while 1: #State 0
    if minuend == 0:
        break
    minuend, m_right_bit = divmod(minuend, 2)
    subtrahend, s_right_bit = divmod(subtrahend, 2)        
    if     m_right_bit == 0 and s_right_bit == 0:
        difference = '0' + difference
    elif   m_right_bit == 1 and s_right_bit == 0:
        difference = '1' + difference
    elif   m_right_bit == 1 and s_right_bit == 1:
        difference = '0' + difference
    else:# m_right_bit == 0 and s_right_bit == 1:
        #State 1
        difference = '1' + difference
        while 1: #State 1
            if minuend == 0:
                break
            minuend, m_right_bit = divmod(minuend, 2)
            subtrahend, s_right_bit = divmod(subtrahend, 2)        
            if     m_right_bit == 0 and s_right_bit == 0:
                difference = '1' + difference
            elif   m_right_bit == 0 and s_right_bit == 1:
                difference = '0' + difference
            elif   m_right_bit == 1 and s_right_bit == 1:
                difference = '1' + difference
            else:# m_right_bit == 1 and s_right_bit == 0:
                difference = '0' + difference
                break # back to State 0     
            continue
    continue

if True: #debugging
    print('Answer (subtraction):', difference)    
    if int(difference, 2) != M -S:
        print('Program failed...')

raise SystemExit

Challenge

Code to perform the same subtraction as my Python program; no output should be produced.

Standard code-golf rules apply. The shortest code in bytes wins.

Answer 16

Multiple Averages

code-golf math

In math, the average or mean of a range of numbers is in the middle of all of the numbers. The farthest number in the range from the average is as close as possible to it. So, to find multiple averages of a range of numbers, one would have to find numbers that best represent the numbers in the collection that are closest to them.

For example, the two averages of the range from 1 to 5 are 2 and 4. 2 represents the numbers 1-3, while 4 represents the numbers 3-5. Below is a diagram to help understand why these numbers best represent the range.

A simple way to calculate the averages is to divide the range into equal parts and calculate the average of each part. For the previous example, the average of 1-3 is 2 and the average of 3-5 is 4.

Challenge

Create a program that takes three inputs: a number f, another number l and a positive integer n, and outputs the n averages of the range of integers from f to l, inclusive. Assume that there are n or more numbers within this range.

Rules

• Output can be a list/array or a string of numbers separated by spaces.
• The order of the output does not matter.
• Standard loopholes are not allowed.
• This is code-golf, so the shortest code wins.

Test Cases

f	l	n	Output
1	3	2	1.5, 2.5
5	5	1	5
4	25	2	9.25, 19.75
42	-4	3	3.666..., 19, 34.333...
0	27	4	3.375, 10.125, 16.875, 23.625
7	2.5	3	3.25, 4.75, 6.25

Sandbox Questions

• Is the explanation clear enough?
• Is this challenge fit for code-golf?
• Is this challenge too hard or easy?
• What should be changed?

Answer 17

Most Contrasting Background Color

code-golfcolor

When putting colored text on a background, the text can sometimes be hard to read because the text color does not contrast with the background color well. Thus, this challenge will be to create a function or program that can find the most contrasting background color for a given text color.

Challenge

Create a function or program that takes a text color (in RGB format) and outputs the farthest color from the text color, which would be either "black" or "white" as a string. This will be based on the relative luminance of the text color, which is an approximation of how light or dark a color is based on human perception. The relative luminance can be calculated with this formula:

\$Y=0.2126R+0.7152G+0.0722B\$

If the relative luminance is closer to 255 (white), then the program should output "black" and vice versa.

Rules

• Output should be a string: "black" or "white".
• Standard loopholes are not allowed.
• This is code-golf, so the shortest code wins.

Test Cases

Input	Output
255, 0, 0	"white"
0, 0, 0	"white"
255, 255, 255	"black"
0, 255, 255	"black"
133, 193, 230	"black"
100, 62, 139	"white"
128, 128, 128	"black"

Sandbox Questions

• Is this a dupe?
• Is the challenge clear enough?
• What should be changed?

Answer 18

Unlolify a lolified message!

Answer 19

Implement a tag system simulator

Answer 20

Convert chessboards to algebraic notation

code-golfchess

---

Note: this is "simple" algebraic notation. It is only based off of my very limited knowledge. En passant, draw offers, disambiguation etc are not included and no bonuses will be given for handling those cases.

Algebraic notation is a compact, universal chess notation which provides an easy method of communication between two chess players. There are many apps that can convert a game of chess into algebraic notation given a list of boards; in this challenge you will write one as well.

Before I go over the challenge details, here's a quick crash course of algebraic notation.

Castling: there are two types of castling: kingside castling, the "short" way, and queenside castling, the "long" way. The short way is denoted as O-O (or 0-0) and the long way is O-O-O (or 0-0-0). When castling is performed, the king and rook both move at the same time, making castling the only occasion when two pieces can move at the same time.

K..R -> .RK. (kingside)
R...K -> ..KR. (queenside)

Other moves: the rest of the time, only a single piece moves. The move's anatomy in algebraic notation looks like this:

• the first character is the piece type, except when a pawn is moving. In the case of the pawn the piece type is not included. Otherwise, a knight is N, king is K, rook is R, queen is Q and bishop is B.
• next, we add x if the move is a capture. If not add nothing.
• Then, as a chessboard "coordinate", the position that piece is moving to. For example a4, b5 etc:

a8 b8 c8 d8 e8 f8 g8 h8
a7 b7 c7 d7 e7 f7 g7 h7
a6 b6 c6 d6 e6 f6 g6 h6
a5 b5 c5 d5 e5 f5 g5 h5
a4 b4 c4 d4 e4 f4 g4 h4
a3 b3 c3 d3 e3 f3 g3 h3
a2 b2 c2 d2 e2 f2 g2 h2
a1 b1 c1 d1 e1 f1 g1 h1

So a pawn moving to e4 would be e4, a bishop moving to h5 capturing a piece there would be Bxh5, a rook moving to g6 would be Rg6, etc. Note that pawn capturing at e4 would be xe4.

An additional character is placed at the end in certain circumstances: if the move makes the moving side "check" the opposing side then a + is added. For checkmates we add # instead. Note that this applies to castling as well (O-O+).

I will ignore en passant for this challenge.

Now, for the challenge itself...

You will take in a sequence of boards representing an entire game, and output its corresponding algebraic notation.

I don't really care how you take the boards. You could take in a FEN string:

rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR

or a 8-line, 8-column board:

rnbqkbnr
pppppppp
........
........
........
........
PPPPPPPP
RNBQKBNR

or a list of pieces:

['W', 'R', 'a8'], ...

or whatever else is reasonable. I will not accept taking in algebraic notation-like strings like Ra8 Kb7, for instance. You can take in a list of boards, double-newline separated, etc.

For each board you must output the algebraic notation of the move from the previous board to the current board by inferring the move from the difference between the boards, along with any necessary pluses and hashes in case the move is a check or checkmate. You must output the correct algebraic notation, but the end "list" can be of any format: a list, space-separated, newline-separated, etc. I don't really care as long as it is reasonable.

Example

Two boards have been given.

rnbqkbnr
pppppppp
........
........
........
........
PPPPPPPP
RNBQKBNR

rnbqkbnr
pppppppp
........
........
........
.......N
PPPPPPPP
RNBQKB.R

Output:

Nh3

Another example:

....k...
........
........
K.......
....b...
....R...
........
.q......

....k...
........
........
K.......
....R...
........
........
.q......

Output:

Rxe4+

And finally, the Fool's mate with black castling once:

rnbqkbnr
pppppppp
........
........
........
........
PPPPPPPP
RNBQKBNR

rnbqkbnr
pppppppp
........
........
........
.....P..
PPPPP.PP
RNBQKBNR

rnbqkbnr
pppp.ppp
....p...
........
........
.....P..
PPPPP.PP
RNBQKBNR

rnbqkbnr
pppp.ppp
....p...
........
......P.
.....P..
PPPPP..P
RNBQKBNR

rnbqkb.r
pppp.ppp
....p..n
........
......P.
.....P..
PPPPP..P
RNBQKBNR

rnbqkb.r
pppp.ppp
....p..n
........
......P.
P....P..
.PPPP..P
RNBQKBNR

rnbqk..r
pppp.ppp
...bp..n
........
......P.
P....P..
.PPPP..P
RNBQKBNR

rnbqk..r
pppp.ppp
...bp..n
........
......P.
PP...P..
..PPP..P
RNBQKBNR

rnbq.rk.
pppp.ppp
...bp..n
........
......P.
PP...P..
..PPP..P
RNBQKBNR

rnbq.rk.
pppp.ppp
...bp..n
........
......P.
PP...P..
R.PPP..P
.NBQKBNR

rnb..rk.
pppp.ppp
...bp..n
........
......Pq
PP...P..
R.PPP..P
.NBQKBNR

Output:

f3 e6 g4 Nh6 a3 Bd6 b3 O-O Ra2 Qh4#

This is code-golf, so the winner is the answer with the least bytes.

---

Meta: is this a duplicate? How could I improve the challenge further?

Answer 21

Make a number serious

I'm a big fan of silly challenges, but I'm afraid we're going to have to get serious. It's time to get rid of the lols.

Or rather, the 101s, which look quite a bit like lols.

Task:

Take an integer as input. You'll make this number serious by removing the 101s from the number's binary representation. Now, particularly good jokes sometimes elicit lolols or even l(ol)+s from numbers, so we must get rid of these too.

Answer 22

C character constants.

I'm not sure if we had something like this before.

Given a value n between 1 and output the shortest possible c type character constant.

Examples:
1 -> '\1'
7 -> '\7'
8 -> '\b'
9 -> '\t'
65 -> 'A'

The character constants can only contain ASCII characters from 32 - 127.

Answer 23

Fast Inverse Square Root //evil floating point bit level hacking

Introduction

The fast inverse square root algorithm is a function developed in C for Quake III. It was at the time the fastest way to compute the inverse square root of a function, which is needed for most vector operations.

The code as written in 1999, from the quake 3 source, is as follows:

float Q_rsqrt( float number )
{
    long i;
    float x2, y;
    const float threehalfs = 1.5F;

    x2 = number * 0.5F;
    y  = number;
    i  = * ( long * ) &y;                       // evil floating point bit level hacking
    i  = 0x5f3759df - ( i >> 1 );               // what the fuck? 
    y  = * ( float * ) &i;
    y  = y * ( threehalfs - ( x2 * y * y ) );   // 1st iteration
//  y  = y * ( threehalfs - ( x2 * y * y ) );   // 2nd iteration, this can be removed

    return y;
}

Challenge

Given a floating-point number in any form you wish, calculate its inverse square root and return it as a float to at least 4 decimal places.

Example

Input:

3

Output:

0.5773502691

Judging

This is a challenge for creativity as well as code size.

For example, I would rate a 1:1 copy in c# about a 3/5, but a brainfuck copy 5/5 for the challenge and creativity.

Answer 24

Apply gravity to this matrix

Answer 25

A *character*-less quine

Similar to “What did we forget?”

---

Output

Your program must be a quine - that is, print its own source code with no input or unused input.

Although this is quine, you are allowed to read your own source code. Assume the file is named “q” and that no extension is needed. There is no bonus for not reading the source code.

If you remove all occurrences of a character that is in your program, it should print the character removed. It is allowed to then raise an error; however, there is no bonus for this either.

To the sandbox: do I need this? => Your program must have at least 3 different characters.

Lowest number of bytes wins (this is code-golf, after all)

Sanbdox things

• Anything I should change?
• This used to be “Numberless” (see edit history) - should I change it back?

code-golf source-layout radiation-hardening quine

Answer 26

Your Challenge

Find out if a function always returns its input.

Input/Output Information

Input is a math expression as a string with operators + - ( ) /.
The multiplication symbol is *, or x if you specify.

The input will always will only contain whitespace spaces, decimal points, numbers (0123456789), math symbols (+ - ( ) / and one of the following: * or x) and one lowercase letter that is the variable.

Whitespace in the input must be ignored.

Output is whether the function will always return its input.

The expression will never have a division by a polynomial with its degree >1.
Example: x*x*x/x*x <= this will never be input.

Example Input/Output

Input: n /3 + 2*n/3 + 175 - 175*(n+ 1-n)
Output: truthy
Explain: Simplifies to "n"

Input: f
Output: truthy
Explain: Any variable is allowed

Input: j*(j-3.1)/(j-   3.1)
Output: falsey
Explain: In normal math, this evaluates to j
However, when j is 3.1, it is undefined
Therefore, it doesn’t ALWAYS return its input
This is because when j is 3.1, the output is not 3.1

Input: 1j
Output: truthy
Explain: 1j = j which is the input

Input: n/2 + n/2
Output: truthy
Explain: Simplifies to 2n/2 = n which is the input

Scoring

This is code-golf, so lowest amount of bytes wins!

Sandbox Questions

I brought this back from a long time ago.

Any unaddressed problems?

code-golf math

Answer 27

Alternating Digit Divisibility

TODO: Could use a better title..

code-golfnumberarithmeticinteger

Challenge:

Given a list of at least two positive integers, output a pair of lists of digits. Both inner lists in the output are the digits which evenly divide each number in the alternating converted lists. The first converted list will be [sum(digits(n)), n, sum(digits(n)), ...], and the second will be [n, sum(digits(n)), n, ...].

Step-by-step example:

Input: [611,44,381]

Step 1: Convert it to the two alternating lists:

[[sum([6,1,1]),44,sum([3,8,1])],    →    [[8,44,12],
 [611,sum([4,4]),381]]                    [611,8,381]]

Step 2: Check for each number which digits evenly divides it:

[[[1,2,4,8],[1,2,4],[1,2,3,4,6]],
 [[1],[1,2,4],[1,3]]]

Step 3: Leave the digits present in each of the inner lists of lists, which is our output:

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

Output: [[1,2,4],[1]]

Challenge rules:

• I/O is flexible. Input can be a list of strings, integers, 2D list of digits, etc. Output can be a list of lists of digits, a single flattened list of digits (i.e. [1,2,4,1] in the example above), two lists printed on separated lines, each digit printed separated, a string or single (big) integer (i.e. 1241), etc. etc.
• You're allowed to swap the order of the alternation if it's convenient in your language of choice (i.e. the example above would output [[1],[1,2,4]]/[1,1,2,4]/1124/etc. instead).
• 0 will never be in the output.

General rules:

• This is code-golf, so shortest answer in bytes wins.
  Don't let code-golf languages discourage you from posting answers with non-codegolfing languages. Try to come up with an as short as possible answer for 'any' programming language.
• Standard rules apply for your answer with default I/O rules, so you are allowed to use STDIN/STDOUT, functions/method with the proper parameters and return-type, full programs. Your call.
• Default Loopholes are forbidden.
• If possible, please add a link with a test for your code (i.e. TIO).
• Also, adding an explanation for your answer is highly recommended.

Test cases:

Input:                      Output:

[611,044,381]               [[1,2,4]], [1]]
[200,32000,4000]            [[1,2], [1,5]]

TODO: More to come, including some larger ones

Answer 28

Encrypt this Message

Answer 29

Draw me a circle

Given a radius \$r\in\mathbb{N}\$ and \$r\geq 3\$, draw an ASCII circle for me, using \$x\$'s. Your circle does not have to look perfect, it just has to be identifiable as one. To make the circle look good, you have to use a \$2:1\$ ratio for width and height of the circles. This is due to characters being taller than wide.

One thing that is required though is an appropriate angle increment. I reccomend \$r\times3\$.

You do not have to account for float rounding errors!

Given the radius \$5\$, your output should look similar to this:

     x x x x x x     
    x           x    
 xx               xx 
 x                 x 
x                   x
 x                 x 
 xx               xx 
    x           x    
     x x x x x x 

IO

Input and output can be in any reasonable form.

More test-cases

Note that these don't have to be an exact match!

3 ->   
        x x xx    
      xx       xx 
     x           x
      xx       xx 
         xx x x  

7 -> 
        xx x x x x xx        
      x               x      
    x                   x    
  xx                     xx  
 x                         x 
 x                         x 
x                           x
 x                         x 
 x                         x 
  xx                     xx  
    x                   x    
      x               x      
        xx x x x x xx  

Answer 30

Drop down the numbers