555
\$\begingroup\$

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

Get the Sandbox Viewer to view the sandbox more easily!

\$\endgroup\$
0

3916 Answers 3916

1
18 19
20
21 22
131
3
\$\begingroup\$

Is This Scrabble Board Valid?

\$\endgroup\$
3
\$\begingroup\$

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!

\$\endgroup\$
1
  • \$\begingroup\$ Because a BF program would likely do destructive edits to the previous terms or add scratch data to the end while advancing the sequence, I'd propose a more rigorous definition: "Write a BF program where, given any prefix of the ABACABA sequence, running the program for some finite number of steps will give the pattern at the start of the tape." \$\endgroup\$
    – Bubbler
    Nov 18, 2021 at 1:32
3
\$\begingroup\$

Light-Cycle KotH

\$\endgroup\$
9
  • \$\begingroup\$ I'd recommend removing all bots that crash in the same turn. Basing it off of external factors like submission dates is a bit unfair. \$\endgroup\$ Sep 13, 2021 at 17:04
  • \$\begingroup\$ My justification for removing only 1 per turn is that it simplifies the logic of generating a leaderboard and removes some edge cases, otherwise things like 3-way ties for first place might be possible if all the bots crash at the same time. \$\endgroup\$
    – thesilican
    Sep 13, 2021 at 20:51
  • \$\begingroup\$ I feel like biasing the rules against newer submissions is fair. After all, new submissions inherently have the advantage that they're able to see the older submissions and can strategize around these existing submissions. \$\endgroup\$
    – thesilican
    Sep 13, 2021 at 20:55
  • \$\begingroup\$ The issue is that the oldest submissions functionally move first, meaning that being the first bot posted is a significant advantage. What about edits? If a bot is changed, does it drop to the bottom? I agree that removing all bots which crash is the right call. \$\endgroup\$ Sep 14, 2021 at 18:36
  • \$\begingroup\$ Hmm... I was going to disallow edits, so that anyone who wanted to update their bot must instead post it as a new bot. @Spitemaster Are edits typically allowed for KotH submission? \$\endgroup\$
    – thesilican
    Sep 14, 2021 at 20:27
  • \$\begingroup\$ Frequently; not always. But you've still got the problem of earlier entries effectively moving first. If you really want to do it this way, it doesn't make sense to have simultaneous movement (because it's not really simultaneous). \$\endgroup\$ Sep 14, 2021 at 20:34
  • \$\begingroup\$ Ok, that seems fair, I will update post to allow for simultaneous movement \$\endgroup\$
    – thesilican
    Sep 14, 2021 at 20:49
  • \$\begingroup\$ If I were you, I'd consider sizing the arena based on number of bots. \$\endgroup\$
    – emanresu A
    Sep 14, 2021 at 20:56
  • \$\begingroup\$ That seems like a reasonable suggestion, what kind of scaling do you think would be good? I'm thinking maybe something like a square with side-length 2n+6, for n players. \$\endgroup\$
    – thesilican
    Sep 14, 2021 at 21:02
3
\$\begingroup\$

Randomly capitalize half of a string

\$\endgroup\$
3
  • \$\begingroup\$ Will a string of length 0 ever be an input? \$\endgroup\$
    – dzaima
    Jun 15, 2017 at 12:26
  • \$\begingroup\$ @dzaima no, clarified by saying length will always be positive \$\endgroup\$
    – Mayube
    Jun 15, 2017 at 13:57
  • 2
    \$\begingroup\$ Change "positive" to "non-zero"? You can't have a negative-length string, last time I checked... \$\endgroup\$
    – pxeger
    Dec 1, 2021 at 18:15
3
\$\begingroup\$

Write a number in overflowed binary

\$\endgroup\$
1
  • \$\begingroup\$ Maybe define a overflowed binary number a binary number where one or more of it's digits goes over 1? \$\endgroup\$
    – Bgil Midol
    Dec 3, 2021 at 17:21
3
\$\begingroup\$

Solve an Inglenook Sidings Puzzle

Tags:

Posted! After about 2 weeks in Sandbox

\$\endgroup\$
3
  • \$\begingroup\$ "Model railroading", not "railroad modeling?" \$\endgroup\$
    – Bubbler
    Nov 25, 2021 at 2:17
  • \$\begingroup\$ @Bubbler specifically model railroading. The puzzle was made to create operational interest on small layouts, since it only needs 2 switches and 4 pieces of relatively short track \$\endgroup\$
    – bigyihsuan
    Nov 25, 2021 at 4:05
  • \$\begingroup\$ So this challenge proposal has been in here for just about a week now; are there any flaws in this? I don't want to post this to the main site and get feedback that should've been caught in meta \$\endgroup\$
    – bigyihsuan
    Dec 1, 2021 at 16:11
3
\$\begingroup\$

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

\$\endgroup\$
5
  • \$\begingroup\$ Unfortunately, this answer broke all "irreducible" challenges. You can execute (almost) arbitrary code unrelated to the task without breaking the "irreducible" requirement. \$\endgroup\$
    – Bubbler
    Apr 22, 2021 at 0:16
  • \$\begingroup\$ @Bubbler Hmm, and I don't think irreducible is a sensible requirement for this either. It definitely makes more sense with bytes than time, along with pristine. I'll have to think about some creative limitations. Maybe unique bytes only? \$\endgroup\$ Apr 22, 2021 at 0:22
  • \$\begingroup\$ Now this is somewhat too close to bignum computation challenge, since all the biggest numbers are actually a fast-growing function applied to some number. They can be trivially converted to take the length of the input, and then used in the algorithm in some way (or just discarded). \$\endgroup\$
    – Bubbler
    Dec 16, 2021 at 8:32
  • \$\begingroup\$ How about this: Choose a decision problem, and write code that solves it, within 100 bytes (or use a partially ordered score instead of a byte limit). Answers are compared based on the minimal time complexity of the problem, not the implementation. So if someone solves an EXPTIME-hard problem, they beat whoever solves a problem in P. This solves the problem of people doing useless calculations, since it doesn't help them. Writing a sorting function that takes exponential time is not in any way better than just doing a sort in O(nlogn) time. \$\endgroup\$
    – AnttiP
    Dec 16, 2021 at 11:25
  • \$\begingroup\$ @AnttiP That could be cool, but it sort of goes against what I was going for (ridiculously slow sorting algorithms). Maybe a separate challenge idea? \$\endgroup\$ Dec 16, 2021 at 14:27
3
\$\begingroup\$

Nth FizzBuzz Number

\$\endgroup\$
1
  • \$\begingroup\$ Maybe allow any different 4 distinct inputs for Fizz, Buzz, FizzBuzz and Number? \$\endgroup\$
    – pajonk
    Dec 16, 2021 at 11:48
3
\$\begingroup\$

Light it up

\$\endgroup\$
4
  • \$\begingroup\$ Maybe you can fill empty cells by some characters like . in your examples and testcases. Or it could be confusing: L.#. is falsy but L.# is truthy, but it is hard to see the difference. \$\endgroup\$
    – tsh
    Nov 2, 2021 at 1:53
  • \$\begingroup\$ @tsh Ok, thanks! \$\endgroup\$
    – emanresu A
    Nov 2, 2021 at 2:02
  • \$\begingroup\$ "some squares are walls, some are empty, and some are lights". Since there are testcases where only empty cell is there, will there be any testcases like ####? \$\endgroup\$
    – tsh
    Nov 2, 2021 at 5:23
  • \$\begingroup\$ @tsh Yes, see the fourth truthy one. I'll be more explicit that some may not occur at all. \$\endgroup\$
    – emanresu A
    Nov 2, 2021 at 6:13
3
\$\begingroup\$

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

\$\endgroup\$
3
  • \$\begingroup\$ Can't find any dupes on this search so it is probably clear. \$\endgroup\$
    – Razetime
    Jan 7 at 4:45
  • 1
    \$\begingroup\$ Closely related \$\endgroup\$
    – pxeger
    Jan 7 at 7:58
  • \$\begingroup\$ @pxeger yeah that's probably similar enough not to post this \$\endgroup\$
    – quintopia
    Jan 7 at 17:37
3
\$\begingroup\$

Remove consistently dependent smaller integers

\$\endgroup\$
2
  • \$\begingroup\$ If lists can be empty I would add an example where one is empty, if they cannot I would make that explicit in the text. Otherwise this seems fine +1. \$\endgroup\$
    – Wheat Wizard Mod
    Jan 6 at 14:20
  • \$\begingroup\$ @WheatWizard i will explicitly specify. Thank you:) \$\endgroup\$ Jan 6 at 14:23
3
\$\begingroup\$

Expand a Rubik's Cube Commutator

Tags:

Posted: Expand a Rubik's Cube Commutator

\$\endgroup\$
5
  • \$\begingroup\$ What do you mean by "expand" the commutator? Also, 3x3x3*, a 3x3 would be a rubik's square :) \$\endgroup\$ Jan 11 at 15:12
  • \$\begingroup\$ @thejonymyster The common names for Rubik's cubes are by the size of a face since they're usually cubes, so we just call them "3x3" for a 3x3x3 cube, etc. Only in cuboids like the 3x3x4 cuboid actually have the 3rd dimension "Expanding" the commutator == Listing out all the moves performed in the commutator \$\endgroup\$
    – bigyihsuan
    Jan 11 at 19:59
  • \$\begingroup\$ ahh, that makes sense, for both parts. +1 \$\endgroup\$ Jan 11 at 20:03
  • 1
    \$\begingroup\$ "Each part of the commutator can be a separate value" - I see this is to make IO more flexible than flat string to flat string, which is good, but I would go further and allow the moves themselves be separate values in each part, and allow a list of moves as the output in order to focus on the challenge itself. This would allow, for example, [["F'", "U2", "R"], ["D", "B2"]] -> ["F'", "U2", "R", "D", "B2", "R'", "U2", "F", "B2", "D'"]. \$\endgroup\$ Jan 11 at 23:07
  • \$\begingroup\$ I couldn't resist and just gave it a go in Jelly and got a 15 byte solution (assuming IO is further relaxed as I suggested, which I believe you will do given your current relaxation). This is a good challenge IMO. \$\endgroup\$ Jan 11 at 23:20
3
\$\begingroup\$

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

\$\endgroup\$
2
  • 1
    \$\begingroup\$ The rules do not actually specify what makes a tower stable. The stable test cases use balancing methods not stated anywhere, and the rules themselves just seem to be more examples. As a non physicist, "use gravity" isn't enough information IMO. This is a cool idea though and +1 once that's fixed \$\endgroup\$ Jan 17 at 13:49
  • \$\begingroup\$ Just highlighting the bars on their own would be interesting IMO \$\endgroup\$
    – emanresu A
    Jan 17 at 18:36
3
\$\begingroup\$

Recursive palindromes

\$\endgroup\$
3
\$\begingroup\$

Shrink ASCII art

\$\endgroup\$
1
  • \$\begingroup\$ convert like ---, 3 to [---, 3]? \$\endgroup\$
    – Fmbalbuena
    Dec 26, 2021 at 0:48
3
\$\begingroup\$

Is this continuous terrain? Part II

\$\endgroup\$
1
  • 1
    \$\begingroup\$ i like it emanresu A! \$\endgroup\$
    – DialFrost
    Jan 19 at 8:50
3
\$\begingroup\$

Only one from each set

\$\endgroup\$
3
  • \$\begingroup\$ "There are no gaps in the numbers " does it means that the input flattened must contain all the numbers [1..n] where n is the maximum number in it? \$\endgroup\$
    – AZTECCO
    Jan 23 at 10:31
  • \$\begingroup\$ @AZTECCO Yes, exactly \$\endgroup\$
    – AnttiP
    Jan 23 at 10:32
  • \$\begingroup\$ Ok, i think you should explain it, careful.. there are some test cases non valid. I think you may also specify that inner lists are sorted (if it's so I guess) \$\endgroup\$
    – AZTECCO
    Jan 23 at 10:40
3
\$\begingroup\$

Shanghai ascii game sticks

Posted

\$\endgroup\$
4
  • \$\begingroup\$ Looks great, ready to post \$\endgroup\$
    – ophact
    Jan 21 at 10:38
  • \$\begingroup\$ @ThisFieldIsRequired thanks, I still got something to tweak.. I'm gonna take some time \$\endgroup\$
    – AZTECCO
    Jan 21 at 12:32
  • \$\begingroup\$ How are the last two testcases possible? \$\endgroup\$
    – emanresu A
    Jan 22 at 19:29
  • 2
    \$\begingroup\$ @emanresu A the last test case is an edge case were 4 sticks are all bounded and one sits by itself and satisfy the one and only one stick removable condition, you are not required to remove all sticks but just the first \$\endgroup\$
    – AZTECCO
    Jan 22 at 20:11
3
\$\begingroup\$

Highlight a Wordle guess

\$\endgroup\$
7
  • \$\begingroup\$ confused to be honest . maybeeee abit too hard? \$\endgroup\$
    – DialFrost
    Jan 17 at 9:57
  • \$\begingroup\$ @DialFrost Can you be more specific? What part are you confused about? \$\endgroup\$
    – pxeger
    Jan 17 at 9:58
  • \$\begingroup\$ er mostly about the highlighting value \$\endgroup\$
    – DialFrost
    Jan 17 at 10:00
  • \$\begingroup\$ @DialFrost do you mean: 1) you don't understand when to highlight the letters in which colour; or 2) you don't understand how the output values used for highlighting can be chosen? Or something else? \$\endgroup\$
    – pxeger
    Jan 17 at 10:01
  • \$\begingroup\$ both i dont understand \$\endgroup\$
    – DialFrost
    Jan 17 at 10:01
  • \$\begingroup\$ @DialFrost without some more details on what you're missing, I can't help you to understand or clarify the description. What bits you do you understand? \$\endgroup\$
    – pxeger
    Jan 17 at 10:05
  • \$\begingroup\$ pretty much none i just meant i dont understand the hilighting value and how it works the most \$\endgroup\$
    – DialFrost
    Jan 17 at 10:06
3
\$\begingroup\$

Reversed Multiple Pair

\$\endgroup\$
5
  • \$\begingroup\$ maybe give an example and a step by step of evaluating if it is reversed multiple? \$\endgroup\$ Jan 13 at 20:19
  • \$\begingroup\$ @thejonymyster Done \$\endgroup\$
    – Bgil Midol
    Jan 13 at 20:29
  • 3
    \$\begingroup\$ really simple, but it is clearly specified. seems like a decent easy challenge. To make it slightly more difficult you can make this a challenge of finding all reversed multiple pairs under a given limit. \$\endgroup\$
    – Razetime
    Jan 14 at 3:35
  • \$\begingroup\$ @Razetime codegolf.meta.stackexchange.com/a/9384/105116? \$\endgroup\$
    – Bgil Midol
    Jan 14 at 15:31
  • \$\begingroup\$ it's your choice whether that change makes it more interesting or whether it is an unnecessary burden. \$\endgroup\$
    – Razetime
    Jan 14 at 15:55
3
\$\begingroup\$

Cubax Folding Game

\$\endgroup\$
3
\$\begingroup\$

Happy new year string builder

Posted here.

\$\endgroup\$
2
  • \$\begingroup\$ The regex should probably be /^(have a )?happy new year( to you)?!*$/i (removed unnecessary grouping, added string start and end match, and the i tag means the search is case insensitive by default.) \$\endgroup\$
    – hakr14
    Feb 7 at 23:12
  • \$\begingroup\$ @hakr14 thanks, editing the answer. \$\endgroup\$
    – ophact
    Feb 8 at 6:07
3
\$\begingroup\$

The Con Man

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?
\$\endgroup\$
2
  • \$\begingroup\$ And if the bot runs out of money, does it die or can it take a loan? It can't give out loans obviously right? \$\endgroup\$
    – ophact
    Feb 15 at 8:41
  • \$\begingroup\$ @ophact I think it should die since no reasonable strategy would accept a deal with a bot with no money. \$\endgroup\$ Feb 16 at 2:16
3
\$\begingroup\$

Largest rectangle in a skyline

\$\endgroup\$
3
\$\begingroup\$

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 so shortest code in each language wins.

\$\endgroup\$
1
  • \$\begingroup\$ Still don't quite understand what is uniformly randomly choose here mean. For example, the board is OXO/XOX/OOO. If we first choose one coin, and then choose its direction, it will have 1/5 chance to chose the O in the middle. But if we list all possible moves and choose one from them, the middle one should have a 1/3 chance. \$\endgroup\$
    – tsh
    Feb 21 at 6:20
3
\$\begingroup\$

Draw an ASCII Volume

Posted here

\$\endgroup\$
3
\$\begingroup\$

Posted here

\$\endgroup\$
3
  • 2
    \$\begingroup\$ What is the order each rules applied? For example, for rules "11=12", "12=21", "22=3". If input is "1112", should it be "1112 -> 1212 -> 2121" or "1112 -> 1221 -> 131" or "1122 -> 1222 -> 123"? \$\endgroup\$
    – tsh
    Feb 22 at 7:58
  • \$\begingroup\$ All of them. See the original specification for Shue in the linked challenge, or the interpreter. \$\endgroup\$
    – Seggan
    Feb 22 at 15:11
  • \$\begingroup\$ As challenges should be self-contained, I suggest you add the mathematical definition from my post (and maybe an informal explanation of how the rules are applied non-deterministically) \$\endgroup\$
    – AnttiP
    Feb 22 at 16:46
3
\$\begingroup\$

Draw a Signal strength indicator

Posted here

\$\endgroup\$
3
\$\begingroup\$

Convert to UTF-∞

\$\endgroup\$
1
  • \$\begingroup\$ I believe if Unicode code points are used up. They are most probability caused by CJK characters. Until then, there are already >50% used code points represent CJK characters. And characters used by Chinese dialect other than Cantonese (HK source) are still missing in Unicode. \$\endgroup\$
    – tsh
    Feb 22 at 8:23
3
\$\begingroup\$

Ragged slice

Your task is to slice a ragged list. Your input is a ragged list and two lists of integers, corresponding to the beginning index and end index of the slice, where the beginning index is inclusive and the end index is exclusive.

Explanation

Let's start from the very basics. How does regular slicing work? Let's say we have the list [a,b,c,d,e,f] and we want the slice [1,4]. How does this work? Here is an illustration:

[a,b,c,d,e,f]
^ ^ ^ ^ ^ ^ ^
0 1 2 3 4 5 6
  v v v v
  [b,c,d]

This means that [a,b,c,d,e,f][1,4]==[b,c,d]. Ragged slicing is a bit tricky, so please make sure that the previous diagram is mostly clear. Ok, now ragged lists.

Let's first just draw the indices like previously for the list [a,[b,c],[d,[e]],f]:

[a, [b,c] , [d, [e] ] ,f]
^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^
0 1 1 1 1 2 2 2 2 2 2 3 4
    0 1 2   0 1 1 1 2
                0 1

Now, let's see what a slice of [1 1, 2 1 0] would look like:

[a, [b,c] , [d, [e] ] ,f]
^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^
0 1 1 1 1 2 2 2 2 2 2 3 4
    0 1 2   0 1 1 1 2
                0 1
      v v v v v v       
      ,c] , [d, [
       c] , [d
     [[c] , [d]]

The last steps are probably the most confusing. But basically we want to do two things, in the following order:

  1. Trim the left side until an element, or an opening bracket is encountered. Do the same on the right side, except with a closing bracket.
  2. Balance the remaining brackets and keep the depth of every array element the same as in the input, by wrapping the output in brackets.

Now, let's look at what happens when we have empty arrays. In fact, let's replace every letter in our previous example with an empty array:

[[] , [[] ,[] ] , [[] , [[] ] ] ,[] ]
^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^
0 0 1 1 1 1 1 1 2 2 2 2 2 2 2 2 3 3 4
  0   0 0 1 1 2   0 0 1 1 1 1 2   0
        0   0       0   0 0 1
                          0
          v v v v v v v v
          ,[] ] , [[] , [
           [] ] , [[]
         [[[] ] , [[]]]

Notice that for the empty array, the starting bracket doesn't have an index. This is because for an empty array, an index of 0 is already "one past the end" in an empty array, so there is no smaller index for the beginning.

If we would have used index 2 1 0 0 as the ending index, then this would have happened:

[[] , [[] ,[] ] , [[] , [[] ] ] ,[] ]
^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^
0 0 1 1 1 1 1 1 2 2 2 2 2 2 2 2 3 3 4
  0   0 0 1 1 2   0 0 1 1 1 1 2   0
        0   0       0   0 0 1
                          0
          v v v v v v v v v
          ,[] ] , [[] , [[]
           [] ] , [[] , [[]
         [[[] ] , [[] , [[]]]]

Lastly, let's see what happens if the slice is empty. We'll use [1 1 0, 2]:

[[] , [[] ,[] ] , [[] , [[] ] ] ,[] ]
^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^
0 0 1 1 1 1 1 1 2 2 2 2 2 2 2 2 3 3 4
  0   0 0 1 1 2   0 0 1 1 1 1 2   0
        0   0       0   0 0 1
                          0
            v v v
            ] ] ,

Here after step 1, the input just disappeared. We'll just return the empty list [].

Rules

Your input will contain only lists (no numbers, letters, etc.), and the starting and ending index. Indices can in bounds or one past the last in some array. Indices are non-empty lists of non-negative integers. The starting index is not greater than then ending index.

You can choose the order of the indices and also if they are 0 or 1 based (but they must be inclusive-exclusive).

This is so shortest code wins.

Meta

This is a bit tricky to explain. If there were parts that were unclear, or poorly written, etc. then please comment. If you think there is a better explanation, please also let me know.

\$\endgroup\$
4
  • \$\begingroup\$ I don't get why sometimes the opening bracket is indexed, and sometimes not. Could you explain? \$\endgroup\$
    – pajonk
    Feb 27 at 16:41
  • \$\begingroup\$ @pajonk I've added a paragraph explaining that. Basically it only happens for empty lists (that the starting bracket doesn't have an index). \$\endgroup\$
    – AnttiP
    Feb 27 at 16:57
  • \$\begingroup\$ Ok, that was a little confusing. Suggestion: replace empty lists with elements (like numbers) and disallow empty lists - wouldn't this be +/- equivalent and easier to explain? \$\endgroup\$
    – pajonk
    Feb 27 at 17:06
  • \$\begingroup\$ I would suggest simply index any elements and the ending of an array. So for example, Array [1, 2, 3] is indexed as [ 0=>1 1=>, 2 2=>, 3 3=> ]. And a slicing simply exclude the ending element. \$\endgroup\$
    – tsh
    Mar 1 at 7:56
1
18 19
20
21 22
131

You must log in to answer this question.

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