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

Visual Encoding

I want to create a program to randomize certain words, however, I would like all the swapped letters to have the same form factor as the previous one.

Challenge

Given a string of only lowercase letters (and no spaces), randomize its letters according to the following groups:

1: acemnorsuvwxz
2: bdfhiklt
3: gpqy

Each letter cannot be transformed into the same letter as it started as. Additionally, choosing the new character must be uniformly random (within codegolf guidelines).

One final thing is that for the letter j, it must be transformed into either group 2 or group 3, and this can be done by either:

Uniformly choosing between each group and then uniformly choosing a letter or Uniformly choosing between any of the letters in both groups

Note that nothing can turn into j itself.

Examples

helloworld -> kadfrszmhl
jamaica -> genokac
jamaica -> penokac
abpj -> odyt

This is code-golf so the goal is to create the shortest answer in bytes.

Answer 2

Find the necessary Files

code-challengetest-batteryblack-box-function

Let's assume you have program that needs some of the files in a given folder to run. But not all the files in this folder are actually necessary. You can only find out which are necessary be removing/adding files from/to that folder, running the program and then observing whether it runs or throws or fails. The goal is finding exactly the necessary set of files with the minimial number of calls to the program.

Let's formalize it a little bit:

You are given a black-box-function \$ f: \{0,1\}^n \to \{0,1\} \$ that is of the form \$f(x_1, \dots, x_n) = \prod_{i \in I} x_i\$ where \$I\subseteq \{1,2,3,\ldots,n\}\$.

Your goal is finding \$I\$.

Your program may only interact with \$f\$ by evaluating it at various \$x \in \{0,1\}^n\$.

Your score is \$ S= \prod_{m=1}^M (1+s_k)\$ where \$s_k\$ is the number of evaluations of \$f\$ you needed for the example \$k\$ in the test battery. The least score wins.

Test Battery

META: Not sure yet if I should explicitly define a test battery or just let participants iterate through all possible functions up to some \$n\$.

In the following list, the first column represents \$n\$ (the number of arguments) followed by the set \$I\$:

n  | I
3  | 1
3  | 1 3
3  | 1 2 3
4  | 2 3 4
10 | 1 3 5 6 7 9

The last entry for instance represents the function \$ f(x_1, x_2, \ldots x_{10}) = x_1 \cdot x_3 \cdot x_5 \cdot x_6 \cdot x_7 \cdot x_9\$

Answer 3

Parse some Husk (WIP)

Husk is a "functional golfing language inspired by Haskell." Its syntax is prefix, albeit with a twist: Husk's functions can be curried: so uses its static typing to determine how many arguments a function should take at a time. For example, Husk can tell that m+2:2;3 should be parsed as m(+2)(:2(;3)) and not, say, m(+2(:2(;3))) or m(+)(2:2;3), which are meaningless.

Task

This challenge involves validating a subset of Husk that has 5 functions and two types: integers 0-9 or lists of those integers. It also does not have parentheses or overloading. Your submission will take a string consisting only of the characters mo;:+0123456789 and determine whether it is a valid program according to the rules below.

In the following descriptions, "unary integer function" refers to a function that takes an integer and outputs another. It's a made-up term, let me know if there's a better one. "list" refers to a list of integers, and "integer" refers to an integer 0-9. You don't need to understand the purposes of each function, just the types of their inputs and outputs.

• 0-9 are values/integers.
• ; is the unary function singleton. Its argument is an integer x, and it returns a list ([x]).
• : is the binary function prepend. Its first argument is an integer x and the second is a list l. It returns x prepended to l ([x, ...l]).
• m is the binary function map. Its first argument is a unary integer function f and the second a list of integers l. It returns [f(l[0]), f(l[1]), ..., f(l[-1])].
• o is the trinary function compose. Its first argument is a unary integer function f and the second a unary integer function g. The third is an integer x. It returns f(g(x)).

Here is what their types might look like in Haskell:

(;) :: Int -> [Int
(:) :: Int -> [Int] -> [Int]
m :: (Int -> Int) -> [Int] -> [Int]
o :: (Int -> Int) -> (Int -> Int) -> Int -> Int

Here is pseudo-pseudo-pseudo-not-even-BNF-anymore:

<int> ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | + <int> <int>
<list> ::= ; <int> | : <int> <list> | m <unary-int-int> <list>
<unary-int-int> ::= o <unary-int-int> <unary-int-int>
<valid-husk-program> ::= <int> | <list>

Questions for Meta:

• Is this collection of functions okay? Should I add more or replace/remove some?
• Is this challenge interesting?
• Is this a dupe?
• Is the explanation good enough? How can I make it clearer?
• This currently doesn't have a lot of variety in the currying. Should the functions given to map/compose also be allowed to input/output lists? (and if so, would lists be allowed to be nested?)
• Can Perl regex do this? I'm making this challenge hoping that it can't.

Answer 4

Volume of a 3d model

In this challenge, you'll take a shape as input, consisting of a number of triangles forming an outer shell. Your task will be to find the volume of the resulting shape.

You can assume the triangles all connect to exactly one other triangle per side, and the surface does not cross over itself. You will not get an input where two separate solids touch only at points or edges.

Test cases and sample implementation coming soon

Answer 5

Pythagorean triples given the hypotenuse.

Answer 6

Is This Scrabble Board Valid?

Answer 7

Leave ABACABA on the tape

Note that will be removed post sandboxing: This challenge is Brainfuck-specific, but I hope that its contents make the reason why sufficiently clear.

Write a brainfuck program which leaves the following sequence on the tape:

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

This sequence may be familiar to some as ABACABADABACABA... or A007814.

Assume an implementation of BF with an endless tape and arbitrarily large (but not arbitrarily small) integers.

You should link to a visualizer to prove that your program works as you say it does, but if this isn't fast enough to witness the first few (say 4) numbers in ABACABA you'll have to explain it yourself.

This is code-golf, so the shortest program operating within these rules wins. Have fun!

Answer 8

Light-Cycle KotH

Answer 9

Randomly capitalize half of a string

Answer 10

Write a number in overflowed binary

Answer 11

Sum powers to n

Posted to main

Answer 12

Solve an Inglenook Sidings Puzzle

Tags: code-golfgamepuzzle-solver

Posted! After about 2 weeks in Sandbox

Answer 13

Worst time complexity in under 100 bytes

Time complexity, typically represented in Big O notation, represents how long a program will typically take to run given some input(s), ignoring constants.

Your task is to do one of the following things, with the worst time complexity possible:

• Sort an array of integers
• Find duplicates in an array
• Find longest strictly increasing slice of an array of integers

Tasks:

All of the tasks involve taking one input, an array of items, in any reasonable format, and returning an array. If your language supports mutable array data types, this is an allowed output format. Assume all items in the arrays will be (not necessarily positive) integers.

If you choose sorting: You may choose to sort the array by minimum or maximum.

If you choose listing duplicates: You may include a duplicate item any number of times in the output; [1, 2, 2, 3, 4] could result in [2, 4], [2, 2, 4], or even [2, 4, 4, 4].

If you choose longest strictly increasing slice: Duplicate items do not count as increasing, so [1, 2, 2, 4] is not strictly increasing. The items do not have to increase by a steady amount; [-1, 4, 14, 16, 17] is strictly increasing.

Rules:

Your program must be 100 bytes or less. Your program should terminate in a finite amount of time. You can assume your program will never run out of memory, and it does not have to terminate before the heat death of the universe.

This is a code-challenge. The winner will be based on the average time complexity, with slower being better, followed by the best case and then worst case for ties.

Answer 14

Nth FizzBuzz Number

Answer 15

Light it up

Answer 16

Print □□Square□□ Numbers

Your task is to write a program or function that accepts an integer as input/argument and prints/returns all square numbers from 0 up to but not including n².

But the numbers should not just be perfect squares in the mathematical sense. They should be square in every sense. That is, the digits should

• • occupy a square space, 5 lines by 5 columns (including separating space)
• • form right angles at their joints
• • be formed entirely from □ and space characters

Actually, the digits must be shaped exactly like these:

   □ □□□□ □□□□ □  □ □□□□ □□□□ □□□□ □□□□ □□□□ □□□□ 
   □    □    □ □  □ □    □       □ □  □ □  □ □  □ 
   □ □□□□ □□□□ □□□□ □□□□ □□□□    □ □□□□ □□□□ □  □ 
   □ □       □    □    □ □  □    □ □  □    □ □  □ 
   □ □□□□ □□□□    □ □□□□ □□□□    □ □□□□ □□□□ □□□□ 

Note the single column of space between each digit. Spaces at the end of each line are optional. (The three empty columns of spaces on the left side of the digit 1 are not optional.)

Each square number shall be printed on exactly 5 lines using these digits, and between each of these numbers shall be a single line containing no non-whitespace characters. You may optionally include extra blank lines at the beginning or end of the output.

Standard loopholes etc. Shortest solution in bytes is the coolest of beans.

Example Output (given the input 5):

□□□□
□  □
□  □
□  □
□□□□

   □
   □
   □
   □
   □

□  □
□  □
□□□□
   □
   □

□□□□
□  □
□□□□
   □
□□□□

   □ □□□□
   □ □
   □ □□□□
   □ □  □
   □ □□□□

(Note for sandbox: I know this is a good challenge because I had fun solving it myself. But I am worried there is another challenge I haven't seen that is too similar. Please let me know. I'll abandon it if so.)

Answer 17

Expand a Rubik's Cube Commutator

Tags: rubiks-cubestringcode-golf

Posted: Expand a Rubik's Cube Commutator

Answer 18

Will the tower balance?

You are given as input a tower made of bars of unit height, and your task is to decide if the tower is stable. Here is an ascii art drawing of a tower:

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

For extra clarity here is the same tower but with the different bars in different characters:

 A
BBBB
C DDDD
EEEEE

The bars are rigid, but they are not connected to each other. Even though the bars are not connected, they stay still under the influence of gravity. Here however is a tower that is not stable:

      B
CCCCCCCC
   D
  EEE
FFFFFFFF

In this tower, under the influence of gravity, the top bar will fall to the right.

The following tower is metastable:

AA
B

The center of mass of the A-bar lies on top of the edge of the B-bar. In this kind of situation the tower is considered unstable, since even a small perturbation will cause it to fall eventually.

Input/output format

The input format is an ascii drawing of the tower like so:

 ###
  #
### #

In this picture there are 4 bars. It is guranteed that all bars are on top of another bar or on top of the ground and that every row has at least one bar. You can use a different printable ascii character instead of #. You can also take a 2d array instead of a string and use two distinct values for # and . In that case please use simple values, that don't encode extra information (standard loopholes prohibited).

Output two distinct values for STABLE and UNSTABLE.

Test cases

#

STABLE

###
 #
 ##
  #

UNSTABLE

  ###
 ###
###

UNSTABLE (metastable)

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

STABLE

###
 #
#####
 #

STABLE

 #
#####
 #

UNSTABLE

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

STABLE

Answer 19

Recursive palindromes

Answer 20

Shrink ASCII art

Answer 21

Is this continuous terrain? Part II

Answer 22

Only one from each set

Answer 23

Shanghai ascii game sticks code-golfascii-artpath-finding

Posted

Answer 24

Highlight a Wordle guess

Answer 25

Reversed Multiple Pair

Answer 26

Cubax Folding Game

Answer 27

Happy new year string builder

Posted here.

Answer 28

The Con Man

king-of-the-hill

The bots start with a balance of 100 points each. Each round is a 1v1 between two bots. One bot is the Proposer and the other is the Receiver.

P provides R with two numbers: think of it as a loan and repayment with interest. For example, P could propose (50, 60) which means that P wants to swap 50 points for 60 points with R. P also decides whether or to scam R. If R accepts, P can scam R by not upholding their end of the deal and instead taking the 50 points outright.

The twist is, R can see the outcomes of past transactions of P to determine whether or not to trust P and accept the offer.

The format of the tournament is that of a round robin where every bot will play P and R the same number of times against all opponents, in an unspecified order.

Whichever bot ends up with the most points wins.

The language of this challenge is JS.

Format (in TypeScript):

type Bot = {
  R(
    offer: [number, number], // loan, repay
    opponentBalance: number,
    pastTransactions: [number, number, number][] // loan, repay, outcome (0 -> accept, 1 -> reject, 2 -> scam)
  ): boolean,
  P(
    opponentBalance: number,
    pastTransactions: [number, number, number][]
  ): [number, number, boolean] // [loan, repay, scam]
}

Meta

• Does this make for diverse enough strategies to be worthwhile?
• Should more or less information about the opponent be supplied to the players?

Answer 29

Largest rectangle in a skyline

Answer 30

Golfing Coins (suggested rewrite)

The challenge is to write a program that begins with a board like this:

O O X
O O X
O O X

The O's are coins. X's are empty.

Rules

Every round you will uniformly randomly choose a coin and a cardinal direction. You will move that coin 1 spot in that direction, if there is an empty space there. Or in other words, moves must satisfy the following rules:

• The coins can only move up, down, left or right 1 spot.
• Coins cannot move outside the board
• Coins cannot overlap

This process should be repeated until every coin has moved into each spot on the board. You should output the state of the board after every move.

This is code-golf so shortest code in each language wins.