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

Print every Unicode character (almost) code-golf unicode

Print every Unicode character, except U+0000. Any order is allowed.

Specification

Every Unicode character from U+0001 to U+10FFFF, inclusive. Exclude U+D800 to U+DFFF inclusive as apparently these 'surrogates' cause weird behaviour.

To be honest, I don't know much about Unicode so before this gets posted someone will have to fill me in on how Unicode works

Answer 2

Multiply multivariate polynomials

Answer 3

Make a braille cribbage board

The braille characters lie in the range U+2800 (⠀) to U+28FF (⣿), making it a SBCS (Single Byte Character Set). Oddly enough, the braille patterns look a lot like holes in a cribbage board. Here is an image of one of the many cribbage boards for reference:

So you must print this pattern:

+-------+
|⣀⣀⠀⣿⠀⣀⣀|
|⣿⣿⠀⠀⠀⣿⣿|
|⣿⣿⠀⠀⠀⣿⣿|
|⣿⣿⠀⠀⠀⣿⣿|
|⣿⣿⠀⠀⠀⣿⣿|
|⣿⣿⠀⠀⠀⣿⣿|
|⣿⣿⠀⠀⠀⣿⣿|
|⣿⣿⠀⠀⠀⣿⣿|
|⠉⠉⠀⣿⠀⠉⠉|
+-------+

Note that the blanks are U+2800 and NOT the space.

,? is ,7tag3code-golf7'1 s %orte/ code w9s6

Oh, we're not using grade 2 contracted braille. You're not blind.

This is code-golf, so shortest code wins!

---

code-golfunicodeascii-artcard-gamekolmogorov-complexity

Answer 4

Half even rounding

Answer 5

Implement RAID

RAID, or Redundant Array of Independent Disks is a way to efficiently store data in such a way that if any one disk fails you can still recover the data. Instead of implementing the official protocol, any function that can preserve data counts.

Your task is to produce two functions.

The first is the encoder. Given N lists with M elements each, produce N+1 lists with M elements each. What these lists contain is up to you.

The second part is the recovery system. Take as input the lists produced by the encoded, except one is missing. You must be able to recover the original data no matter which of the lists is gone.

Each list should contain only integers between 0 and 255. It is your choice how to represent the empty list, for example you can:

• Replace it with an empty list
• Replace it with a non-list value like None
• Prefix all present lists with a 1 and the missing list with 0.
• Take as a separate input which list is missing then just zero out the values.

Example

A basic XOR based solution could look like this:

Encoder:

def encode(list_of_lists):
    return [*list_of_lists, [reduce(lambda a,b:a^b, i) for i in zip(*list_of_lists)]]

def decode(list_with_one_removed):
    return [
        (i if i else [reduce(lambda a,b:a^b, j) for j in zip(*(k for k in list_with_one_removed if k))
        for i in list_with_one_removed
    ][:-1]

You don't need to use a XOR based solution, as long as you can extract the original data again your solution is valid.

Answer 6

Efficiently solve quadratic equations when 1+1=0

This is a sequel to my previous challenge about solving quadratic equations in the shortest possible code, this challenge is about solving the same task the fastest possible way

The goal of this challenge is to find a solutions for a general quadratic polynomial ax²+bx+c. Meaning be an integer r such that a*r*r+b*b+c is zero, with + meaning exclusive or and * being carry-less multiplication (use xor as addition in binary long multiplication).

To simplify the problem, you can assume that both a and b are one, so you only have to solve equations of the form r*(r+1)=n for an integer n. As any quadratic equation can be converted in this normal form, this is enough to solve the general case (up to linear transformations)

Your challenge will be to solve this simplified equation in the most efficient way possible.

Input: An integer n Output: A number r such that r*(r+1)=n with * being multiplication without carry and + being exclusive or.

Rules:

• You may assume there is an integral solution to the equation
• You only have to return one of the two roots (the other root will only differ in the last bit)
• You program should be able to handle inputs up to at least 0x5555555555555555aaaaaaaaaaaaaaaa
• The algorithm you are using should work for arbitrarily large n
• The program with the lowest time complexity in n wins
• For your score you can assume that xor-addition and xor-multiplication are computed in O(1) (even if your program might need O(n²) operations)
• If multiple programs have the same complexity, the shortest program (per language) wins

Examples (both possible solutions given):

6 -> 2 | 3
20 -> 4 | 5
18 -> 6 | 7
72 -> 8 | 9
78 -> 10 | 11
...
113427455640312821160607117168492587690 = 0x5555555555555555aaaaaaaaaaaaaaaa -> 0xfffffffffffffffe | 0xffffffffffffffff

fastest-algorithm polynomials math

Meta

• Would this be an interesting challenge ?
• Should I extend the challenge to general polynomials (this can be done in O(1) multiplications/divisions after solving the original problem (or computing the normal square root in some cases))?
• Is the rule about multiplication&addition do not count towards the complexity clear?

Answer 7

Golf the fast growing hierarchy

Answer 8

Simulate Round Robin Scheduling

Answer 9

Sokobunny I

Answer 10

Tamagochi

code-golf I can't believe there has never been a Tamagochi challenge on code golf! Edit: There has never been a Tamagochi challenge, but there was a Tamagotchi, whatever that is.

Rules:

• The output must begin with "You found an egg!"
• Text-adventure style tamagochi.
• Prints status changes to stdout.
• Three actions at any moment:
  • Rub/pet
  • Feed
  • Info
• At the start of the program, you must wait for an egg to hatch.
• If not fed for 4 minutes, pet moves down a hunger status
• If fed twice in 4 minutes, pet moves up a hunger status.

Accommodations for golfing languages:

• The language can't access system time:
  • You now have to implement a command wait x, that waits for x minutes.
  • Each newline advances the time by 30 seconds.
• The language can't prompt:
  • Read the input from a file, and provide the file you used to test.
• The language can't read from files:
  • Well, that sucks. Maybe another lang?

Info:

Shows the following:

• Pet name
• Pet age
• Pet hunger
• Pet happiness

Pet Statuses/behavior:

Initial conditions: Hungry (0 food), Sad (0 pets), Age: 0s

Happy: The pet is happy. Transitions to sad in 3 minutes if no interaction.
Sad: Pet needs a petting within 2 minute or becomes sick. Takes t/15 pats to return to happy, where t is in seconds.

Hungry: Pet needs to be fed within 2 minutes, or becomes sick.
Overfed: Pet needs to not be fed more than twice in 4 minutes, or becomes sick. If currently sick and fed by player, advance death timer by 1 minute.
Fed: Reverses the death timer if not sad or dead.

Old: Pet's age + time not in "Happy" and "Fed" > 1h
Sick: Pet will die in 5 minutes, if status causing sick is not cured. If sick with no status, remove sick in one minute.

If a pet dies, prints name, condition(s) and time.
    "Mr. Johnson died of old age, 1h:23m"
    "Tamagotchi died of sadness 0h:7m"

The smallest Tamagochi wins.

Example

The following is an example simulation, where > could be a prompt, or other input as mentioned in accommodations.

Whenever a pet gains or loses a status, it must output {pet name} is no{w | longer} {status}

Termagotchi
You found an egg!
...
The egg is hatching!
...
The egg has hatched!
What would you like to name your pet?
> Mr. Johnson
Mr. Johnson is now hungry.
Mr. Johnson is now sad.
> Info
Mr Johnson
Age: 13s
Hungry, Sad
> Feed
You fed Mr. Johnson.
> Feed
You fed Mr. Johnson.
Mr. Johnson is now fed.
Mr. Johnson is now happy.
> Pet
You petted Mr. Johnson.
> Pet
You petted Mr. Johnson.
> Pet
You petted Mr. Johnson.
> Pet
You petted Mr. Johnson.
...
Mr. Johnson is now sad.
...
Mr. Johnson is now sick.
> Pet
You petted Mr. Johnson.
> Pet
You petted Mr. Johnson.
> Pet
You petted Mr. Johnson.
> Pet
You petted Mr. Johnson.
Mr. Johnson is now happy.
> Info
Mr Johnson
Age: 14m:27s
Happy, Sick
> Feed
You fed Mr. Johnson.
...
Mr. Johnson is now not sick.
...
> Feed
You fed Mr. Johnson.
> Feed
You fed Mr. Johnson.
> Feed
You fed Mr. Johnson.
Mr. Johnson is now overfed.
> Feed
You fed Mr. Johnson.
> Feed
You fed Mr. Johnson.
Mr. Johnson is now sick.
> Feed
You fed Mr. Johnson.
> Feed
You fed Mr. Johnson.
> Feed
You fed Mr. Johnson.
> Feed
You fed Mr. Johnson.
> Feed
You fed Mr. Johnson.
Mr. Johnson died of overfed, 23m:11s

Answer 11

Fastest decimal to binary binary base-conversion fastest-code number

Same challenge, but code golf

Given a decimal number, your task is to convert it to binary.

Test cases

8496867758 -> 111111010011100111110100110101110
28284301455933783441 -> 11000100010000110000001100101000101001000111111110011110110010001
701550526345030865283462565098928586836 -> 1000001111110010011011011101110100010101010100010110011100010101100110100000111111010100100011101000000011010011011100000001010100

Rules

• You can take input either as a string containing decimal digits, or a list of decimal digits.
• You need to output the number in binary, either as a string containing the binary digits or a list of binary digits.
• You are allowed to have leading zeros in the output.
• The input won't contain leading zeros.

Scoring

Your score is the maximum number of digits your code can handle in under a second on my computer (Intel Core i7-9700 with 8 threads, 32GB RAM). If your code takes less than a second for a number with a million digits, you beat all solutions which can't do that, and the tie-breaker is the time it takes for a million digit number.

To calculate the time I will randomly select 10 numbers, and look at the average time.

Meta question

Is this a dupe? I looked for this question but couldn't find it.

I noticed that using GMP's standard I/O functions this takes 0.05 seconds for a million digit number. Is there a point to this question, or is it likely GMP is optimized enough that this will be the winning solution?

Answer 12

Barbrack

Your task is to write a program or function that takes a non-negative integer (in decimal or any other convenient base for your language) and output a number in the numbering system Barbrack.

What's that?

Barbrack is a numbering system I made up that can represent non-negative integers. Zero is represented with an empty string or an underscore, one is represented with [], and all other positive integers can be represented with a brack.

A brack is delimited with brackets [] and works as follows (with an example of 84):

1. Take your number a and find its prime factorization. In this case, the prime factorization of 84 is 2²*3¹(*5⁰)*7¹.
2. Find the indices of these primes, where the index of 2 is 1. In this case, the index of 3 is 2, since it's the prime right after 2, and the index of 7 is 4, since it's the fourth prime.
3. Take the exponents of each prime, and put them in brackets in increasing order of the size of the prime, with consecutive exponents being separated by bars (|). So the general format is [exponent of 2|exponent of 3|exponent of 5…]—in this case, [2|1|0|1]. Minimize the number of cells!
4. Recursively calculate the exponents in Barbrack, remembering that 0 is the empty string and 1 is []. So [2|1|0|1] => [[1]|[]||[]] => [[[]]|[]||[]].
5. Output the final result.

Test inputs

0 -> (nothing)
1 -> []
2 -> [[]]
5 -> [||[]]
45 -> [|[[]]|[]]
84 -> [[[]]|[]||[]]
65535 -> [|[]|[]||||[](48 bars)[]]
65536 -> [[[[[]]]]]

(sidenote: (48 bars) means 48 consecutive bars in the actual output)

Rules

• Standard loopholes apply.
• No input in Barbrack! This isn't a cat challenge!

Scoring

Minimum bytes on a per-language basis.

Answer 13

Factorial Numbers

Write a function or program to print "factorial numbers" as defined in this xkcd comic. Test cases are conveniently provided by the comic too.

You will take an integer number N as input.

You can either

1. output the factorial number representation of N
2. output the factorial number representation of all numbers up to and including N in order (note: must include N; this is different from default rules)

You can assume that the input is not "illegal", but your program must work for all legal inputs. Default loopholes and I/O rules apply. If this can be done in 1 built-in method, you may post it but it will not compete.

This is code-golf so shortest wins. The competition will be between each language, so non-golfing languages should compete.

Answer 14

Golf my code

code-golf code-golf

---

For this challenge, I'll use edit histories of answers to create a dataset of answers that have been golfed. Your task will be to write a program/function that, given a submission that was golfed in the future, will attempt to golf the submission.

You may choose the language, out of a set I'll choose based on the quantity and quality of data available, that your inputs will be in. You may choose to take inputs from multiple languages, which will not be differentiated (e.g., you can choose to score your answer over a combined Python + Jelly dataset).

The first part of your score will be the sum of bytes golfed by your program for each input, with any submissions that don't become shorter (including becoming longer) or become invalid having no impact on your score (might change this later, since otherwise you have no reason not to use a dataset of all languages).

Your final score will be your score, minus the number of bytes in your program. So, if you golf a total of 1920 bytes off the Python answers dataset, with 1080 bytes of code, your final score will be 840. Higher scores are better.

Answer 15

Given A Binary String, Determine Which Of Certain Substrings Are Equal And Opposite

yea the title is going to need some work

Concept

Take an even length binary string

1 1 0 1 0 0 1 0

Between each bit, place an arrow

1 1 0 1 0 0 1 0
 ^ ^ ^ ^ ^ ^ ^

Next, find each substring centered on each arrow which includes either/both the start and the end of the string

1 1
 ^
1 1 0 1
   ^
1 1 0 1 0 0
     ^
1 1 0 1 0 0 1 0
       ^
    0 1 0 0 1 0
         ^
        0 0 1 0
           ^
            1 0
             ^

If each half of the binary string has all of the flipped bits of the other half (in any order), replace the arrow with a 1, else a 0

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

Then get rid of the sublists which will leave you with just the arrows-turned-bits

 0 0 1 1 0 0 1

You must output those bits.

Examples:

00 0
01 1
10 1
11 0
0000 000
0001 001
0011 010
1001 111
1011 100
1100 010
000011 00010
100101 11111
101101 10001
00110011 0101010
00111100 0101010
10101010 1111111
11000101 0111011
11010010 0011001
11100010 0011101

Meta

yea I don't have the vocabulary for this. I'm gonna hammer at it some more but if you read this and something jumps out at you where youre like "oh i know what thats called" Please let me know thank you

Answer 16

Generate Conway's Atomic Elements

Answer 17

Implement the RegPack decompressor

Answer 18

Is it a stable structure? ascii-art

In this challenge, a structure is a combination of row of ---- and columns of |, such that all rows are above at least one column and all columns are on top of either a row or the ground. Additionally, a structure must have all its component rows or columns connected vertically.

For example, the following are structures:

          ---      -----      -----
     |     |        |  |      | | |
|    ---   |----    -- -----  |---|
|     |    |   |    |  |   |  | | |

And the following are not:

|             |                     |
     --    ---|   ---- ---          |-----
|   |  |    | |   |      |     ---  || |

The last two are not structures because, although they satisfy all the other rules, they contain multiple vertically connected parts - specifically, the end of a - cannot connect with the side of a |.

A single row of -s can have multiple |s under it. That row is stable if the center of the row occurs within the span of the |s. For example, take this row:

---X---
 |  ||

The center of that row is the position marked X, and as this falls within the outer two |, the row is stable.

---XX---     ---XX---
   |||          |

You can also have rows with even length, in which case both central positions have to fall within the span of the columns. The first example here is stable, the second is not.

---X---
   |

Rows can even be balanced on a single | as long as their center is on that |.

A structure is stable if every row of ---- in it is stable by the above criteria.

Your challenge is to, given a valid ascii-art structure by the criterion above, determine whether it is stable or not.

Output may either be truthy/falsy using your language's convention (swapping is allowed) or outputting two distinct values for truthy/falsy.

This is code-golf, shortest wins!

Testcases

Truthy

|

-
|

---
| |

  ---
  | |
--- ---
 ||  |

-----
 | ||
 |---
 | |

|
---------
 | |    |


   -------
   |  |
  ------
  | |  |
-----  |
|  |   |

Falsy

--
|

--------
   |

------
| |
------
 |  |

  ---
    |
---------
    |


------------------
 | | |

-------------
|           |
------ ------
|           |

Answer 19

Make a super fair number

Answer 20

Compile Japt to JavaScript

this is a work in progress challenge! the spec is not finished

code-golf parser

[Japt] is a programming language designed by [@ETHProductions] in 2017 designed as a code-golf version of JavaScript (from which its name is derived; JavaScript → Japt). Code written in Japt is compiled to JS code. This challenge is about code-golfing that compilation process.

For this challenge, we will be using a slightly simplified version of Japt that does not support compressed string literals, shortcuts, or ß for recursion. This version of Japt also lacks the semi-famous bug that unterminated array literals make the parser break.

Japt syntax

Japt programs consist of a series of chained function calls (like the JavaScript something.a(1).b(2).c(3)). In Japt, these are written as follows:

a1 b2 c3 

Each lowercase letter tells the parser to start reading arguments, and each space tells it to stop and call the function with those arguments. Here's what passing multiple arguments to functions looks like:

a1,2 b3,4,5 c6 

Japt programs don't just consist of lowercase letters, digits, and spaces. Japt has syntax for four kinds of literals:

1. Numbers, like 1234 or 1.23 or 0.7
2. Strings, like "abcd" or "player 1 has {U} points" (interpolation)
3. Arrays, like [1,2,3] or [1,"a",["b","c",[2]],"d"]
4. Functions, like X{X+1} or XYZ{XaY b5 +Z} (uppercase letters are parameter names, brackets surround function body)

An expression is made of one of the above literals, followed by any number (including zero) of chained function calls.

Note that, when the either the program ends or the parser hits a newline, any unfinished literal or function call is automatically closed:

mX{Xa"bcd

can still be parsed as calling m with a function that takes X and calls a on it with argument "bcd", even though many structures are not fully

Compilation to JavaScript

Japt expressions translate pretty much one-to-one with JavaScript expressions. Many expressions can be translated slightly differently and have the same results, so for this challenge, any output that is equivalent to the JavaScript expression as explained here is OK output. For example, for a1 b2 c3 you may choose to output U.a(1).b(2).c(3) or you might output U.a(1 ).b((2)).c(3 ) or similar.

If a number literal is the first part of a chained function call, it must be either surrounded in parentheses (1.5 becomes (1.5)) or have a trailing space (1.5 ). Your submission may choose either of these. You may also choose to have all numbers follow one of these conventions, not only

Test cases

Japt:
a1 b2 c3
JavaScript:
U.a(1).b(2).c(3)

Japt:
a1b2c3 d4  e5
JavaScript:
U.a(1 .b(2 .c(3).d(4)).e(5)

Japt:
q| mZ{ùT+=Zl} ú mZ{Z+S+V
JavaScript:
U.q("I").m((Z)=>Z.ù(T+=Z.l())).ù().m((Z)=>Z+S+V)

Japt:
1 +2 +3 +4
JavaScript:
(((1)+2)+3)+4

Answer 21

Pushing Penguins on an Integer Iceberg

An iceberg is represented by a rectangular grid of cells. Each cell can hold one of three penguins. Penguins can be pushed in any free orthogonal direction, but they slide until they reach the edge of the grid or would bump into another penguin. Example:

.........
.1.....2.
....3....
.........

If you push each penguin in turn to the right, they will end up in the following positions:

.........
......1.2
........3
.........

Given an initial position and a target cell, your challenge is to push any of the penguins so that it comes to rest in that cell.

You can take the initial position as an iceberg size and list of penguin coordinates, or as an iceberg array of bytes, with one value for the empty cells and one or three distinct values for the penguins. In the latter case the target cell can have its own distinct value or it can be a coordinate. (Although the input can only be bytes the type of the array can be larger.)

The output list of pushes should identify the penguin to be pushed, either by its initial index or its current position, and either the direction (which can be encoded as any four convenient byte values) or target of the push, or if the penguins have three distinct values then it can be a list of updated iceberg arrays each with one penguin having been pushed to a new position from the previous. (The initial position does not have to be included in the output.)

You can assume that the target cell will be in the interior of the iceberg as the edge cells are trivial as they only require two penguins to solve. (And the corner cells are even more trivial as they only require one penguin.)

Your doesn't have to output an optimal solution but it must be deterministic. One approach is to devise a systematic solution that solves every cell on the iceberg but only output as far as the target cell.

This is code-golf, so the shortest program or function that breaks no standard loopholes wins!

Answer 22

Moved to the main site

Answer 23

Challenge - Find the nearest "well known" fraction

Find the nearest useful, well-known fraction for any decimal.

Here I'm defining well-known fractions as

• 1/2s - everyone can get on board with halves
• 1/3s - similarly easy to picture
• 1/4s - slicing up a pizza for greedy people
• 1/5s - at the edge of usefulness, but I think still useful
• 1/6s - only 1/6 and 5/6 are not covered by the above, but it's a pizza slice so just sneaks in

BUT NOT

• 1/7s - no-one uses sevenths
• 1/8s and 1/9s - might as well just go to decimals now

Thus, the challenge is, given any number between 0 and 1, output a numerator and denominator where the latter is between 1 and 6 inclusive, with a forward slash in-between, representing the nearest fraction to the decimal, from the following:

0/1 1/6 1/5 1/4 1/3 2/5 1/2 3/5 2/3 3/4 4/5 5/6 1/1

Zero and One results can either be output as 0/1 or 0, 1/1 or 1

TIE BREAK - where a decimal is equidistant between two common fractions (e.g. 0.775 is equidistant from 4/5 and 3/4), then the LOWEST denominator wins, so an input of 0.775 outputs 3/4.

(Sandbox comment - I hope this isn't trivially easy!)

Answer 24

Twist words to intersect

code-golf

Given three strings of alphabetic characters \$A\$, \$B\$, and \$X\$, (all uppercase or all lowercase, your choice), output an arrangement of \$A\$ and \$B\$ on a grid such that they intersect only at the letters of \$X\$. Each word can start at any location in the grid; after that, every character in the word must be placed in the grid at a location orthogonal (directly above, below, to the left, or to the right) of the previous character. The word must not intersect itself. The grid can be arbitrarily large.

For example, if \$A\$ was ASHAMEFULACT, \$B\$ was CHARACTER, and \$X\$ was HAT, one possible arrangement is shown below.

In text format:

_ _ _ _ _ _ _
_ _ a m e f _
_ c H a r u _
_ a s c A l _
_ _ e T c _ _
_ _ r _ _ _ _
_ _ _ _ _ _ _

(The places where the words intersect are shown in capitals; the rest of the letters are shown in lowercase.)

You can output in any reasonable format -- the format above is not required. For example, you do not need to have the intersecting letters be a different case than the rest of the letters in the words. One possible output format would be a 2D array of characters, like

[ ["",  "A", "M", "E", "F"],
  ["C", "H", "A", "R", "U"],
  ["A", "S", "C", "A", "L"],
  ["",  "E", "T", "C", "" ],
  ["",  "R", "",  "",  "" ] ]

You can assume that such an arrangement is possible to create -- e.g. \$A\$ and \$B\$ will both have the letters of \$A\$ as a subsequence (in order).

Standard loopholes are forbidden. As this is code-golf, shortest program wins.

Answer 25

Print the banned characters based on the most common characters answer-chaining code-challenge restricted-source

This is an answer-chaining post, so in this challenge every answer (except the first answer) depends on the previous answer.

The goal of this challenge is to output the restricted characters based on the most common n characters, if happens to be a tie, then the characters with the lowest UTF-8 range is banned

The max bytes for every answer is:

\begin{align}2n+60\end{align}

where n is answer number

Rules

• The answers only output the restricted characters, no newlines, no other characters like that.

  • The code may output the restricted characters once, in any order.

• Standard loopholes are forbidden by default.

• No answerer may answer twice in a row.

• No languages may used in the last 5 answers (Or any answer if there are less than 5 answers).

• Every answer takes empty or no input, and outputs to STDOUT. No answer should output to STDERR.

• The wrong answers (that break rules or don't do that this challenge say) are completely ignored if this answer is 10 minutes old, and should be deleted.

Scoring

The lowest score is the best. Using this formula:

\begin{align}\frac{b+1}{n+1}\end{align}

Where b is byte count and n is answer number, we can score the answers based on the lowest score. The answer is accepted if the challenge hasn't recieved answers for 5 days.

Tiebreaker is the earliest answer.

Example

First answer

# 1: Python 3

    print(end="")

Character uses:

    ": 2 (Banned)
    n: 2
    (: 1
    ): 1
    =: 1
    e: 1
    i: 1
    p: 1
    r: 1
    t: 1

The second answer should output ". If the second answer's code is ppaaa, then the third answer should output either pa or ap (because you should output two restricted characters), and doesn't use these characters.

Note: The scoring formula is based on the byte count and the answer number. The goal is to output the restricted characters efficiently while adhering to the specified byte limits.

Have a great day!

Answer 26

I'm building a Code-Golf type game for an authorization language. The premise is to review a piece of an authorization policy and the permissions to identify the least number of rules you need to create in order to keep the permissions true.

Example of one policy and two permissions below. What are Alice and Anthony's roles?

• Alice can read Organization metaworldpeace
• Anthony can add_member Organization metaworldpeace

actor User { }

resource Organization { 
    roles = ["admin", "member"];
    permissions = ["read", "add_member"];
# role hierarchy:
# admins inherit all member permissions
"member" if "admin";

# org-level permissions
"read" if "member";
"add_member" if "admin";

   

Answer 27

Can I do this parkour?

code-golf

---

In this challenge, you'll be given a list of platforms (line segments), a start point, a goal point, and your acceleration, stopping, and jump strength. Your task will be to determine whether it's possible to make it from the start point to the goal point by running and jumping on the given platforms.

Physics

I can be modelled as a point, subject to gravity. All positions will be given in meters, and gravity can be assumed to accelerate me downward at \$10\:\mathrm{m/s^2}\$. If I'm standing on a horizontal platform, I can accelerate in a direction I'm moving in (or if I'm at \$0\:\mathrm{m/s}\$) at a rate of \$a\:\mathrm{m/s^2}\$, where \$a\$ is the acceleration taken as input.

(unfinished)

Answer 28

Add two natural numbers

Answer 29

posted: Convert real numbers between factoradic and positive integer bases

Answer 30

Prefix-Suffix equality, part 1

Given an array of two distinct byte-sized values, please perform the following operations or their equivalent:

• Construct an array of its nontrival prefixes and suffixes, starting with the array itself and working down to its first and last elements.
• Compare each element of the two arrays elementwise, with the result 1 if the two elements are identical and 0 if they are not.
• Taking the array of 1s and 0s, interpret that as a number in base 2.
• Double this number.

The result turns out to be the expected number of uniformly random selections between your original two values to get the input array.

Example using H and T as the two byte-sized values:

HTTHT  HTTHT   1
HTTH    TTHT   0
HTT      THT   0
HT        HT   1
H          T   0

Converting 10010 to decimal gives 18, which is then doubled to give the final result of 36. This is the expected number of coin tosses to produce the pattern HTTHT.

This is code-golf, so the shortest program or function that breaks no standard loopholes wins!