Sandbox for Proposed Challenges

Question

What is the Sandbox?

This "Sandbox" is a place where Code Golf users can get feedback on prospective challenges they wish to post to the main page. This is useful because writing a clear and fully specified challenge on the first try can be difficult. There is a much better chance of your challenge being well received if you post it in the Sandbox first.

To post to the Sandbox, scroll to the bottom of this page or click on the "Add Proposal" link below, 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. 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, replace the post here with a link to the challenge and delete it.

See the Sandbox FAQ for more information on how to use the Sandbox.

The Sandbox works best if you sort posts by "active".

Add Proposal

Search the Sandbox

• Most people include applicable tags in their proposal, so for instance you can search for all king-of-the-hill proposals by merely adding the tag name in quotes to the search query.

Browse your pending proposals

Get the Sandbox Viewer to view the sandbox more easily

To add an inline tag to a proposal use shortcut link syntax with a prefix: [tag:king-of-the-hill]

Answer 1

Convert Character Substrings to Numeric

I often have to take character data and categorize it numerically. A common thing I do is to take character type variables and convert them to numeric type characters, keeping same categories according to the level of work I'm doing. (The longer the substring, the more in depth, shorter substrings for broad level). Enough backstory...

The challenge: In as few bytes as possible, convert the input part A, a vector/list of unique strings, into the output, a vector/list of numbers, keeping unique categories within the length of substrings the same length, which is input part B.

Input:

1. w, Vector/list of unique strings of equal character length. n <= 10

   • These strings may be any combination of uppercase letters and numbers. Sorry if it seems my examples follow a pattern, I just created them after a similar pattern I see in the data I work with.

2. s, where 1 <= s <= n

Output: May take input and output in the same order, or you can convert alphabetically, but output in the same order. See example 2. (I've included comments in my output to clarify, this is not required)

Example Input 1:

#Already alphabetized, but this input is not always guaranteed

s = 3, w = 
[ABC01, 
 ABC11,
 ABC21,
 ABD01,
 ABE01,
 ABE02,
 ACA10,
 ACA11,
 ACB20,
 ACB21]

Example Output 1:

[1, #ABC
 1, 
 1, 
 2, #ABD
 3, #ABE
 3, 
 4, #ACA
 4, 
 5, #ACB
 5]

Example Input 2: s = 4, w =

[X1Z123,
 X1Z134,
 X1Y123,
 X1Y134,
 X1Y145,
 X1Y156,
 X1X123,
 X1X124,
 X1X234,
 X2Z123,
 X2Z134,
 X2Z222,
 X2Z223,
 X2Z224]

Example 2 Output:

#Categorize by order
[1, #X1Z1
 1,
 2, #X1Y1
 2,
 2,
 2,
 3, #X1X1
 3,
 4, #X1X2
 5, #X2Z1
 5,
 6, #X2Z2
 6,
 6] 

OR if conversion follows alphabetical formatting,

#Categorize alphabetically, but output in same order as input.
[6, #X1Z1
 6,
 5, #X1Y1
 5,
 5,
 5,
 3, #X1X1
 3,
 4, #X1X2
 1, #X2Z1
 1,
 2, #X2Z2
 2,
 2] 

Answer 2

Partial tq interpreter code-golf interpreter

In this task you are expected to provide a list output given an input tq program. The tq programs will not contain whitespace inside them. (I find tq extremely difficult to implement within a short time, therefore I consider it to be a nice challenge.)

What is tq, in the first place?

tq is a lazy-evaluated language that is designed with the idea that array items should be accessable during the definition of them. In tq, there is no explicit separator of an array, only special arrangements of monadic/dyadic functions and nilads.

The following program is a program printing [123] (Pretend that tq doesn't support strings because we aren't dealing with them in this case):

123

This defines a list with the first item being the number 123, after which all items in the list will be outputted inside a list.

In tq, numbers are supported to allow multiple-digits. So this defines a list with 2 items:

12+12,5

In this test case, you are expected to output the list [24,5]. Let's explain it step by step.

12+12   # This evaluates 12 + 12 in the current item in the list, returning 24
     ,  # A separator. This separates two items when they could be potentially
        # ambiguous when they are applied without a separator.
      5 # This evaluates 5 in the current item in the list, returning 5
        # The comma is simply a no-op that doesn't require parsing.

So you think that tq is not hard at all to implement? Well, remember that tq also has a special feature of accessing the items in an array before the array is defined!

555th123

We introduce two new atoms:

• t (tail) means access the last item in the list
• h (head) means access the first item in the list

Therefore our list is going to yield:

[555,123,555,123]

Now take a look at this program:

555ps123

We introduce 2 more atoms:

• p Yield the next item before (previous) the current position
• s Yield the next item after (succeeding)the current position

This yields the list:

[555,555,123,123]

A quick reference of the tq language

Just assume that you only have two operands for the operators.

• [0-9] starts a number. Numbers will only be positive integers, i.e. no decimals and negative numbers.
• , This is a separator of different items when it is given that two consecutive indexes will be ambiguous with each other without a separator. In tq all of the remaining characters can act as a separator, but in this case it is a good idea to implement only , for the ease of your implementation.
• + and * These are arithmetic operators. Usually in tq, they may be applied multiple times, e.g. 1+2+3, but in your implementation, input will be provided so that this will not happen and only 1+2 will happen (there will not be applications multiple times).
• t return the last item in the list. If the code is t1,2,3 it shall return [3,1,2,3].
• h return the first item in the list. If the code is 1,2,3h it shall return [1,2,3,1].
• p returns the item before the current item. If the code is 0,1,p,3,4 the code shall return [0,1,1,3,4].
• s returns the item after the current item. If the code is 0,1,s,3,4 the code shall return [0,1,3,3,4].

More test cases

• 4p*p will yield [4,16]
• 1p+s2 will yield [1,3,2]
• 1,2,3h+t4,5,6 will yield [1,2,3,7,4,5,6]
• 3ppss6 will yield [3,3,3,6,6,6]
• You also have to implement multiple hops. E.g. 1th should yield [1,1,1]
• If you know that something is going to form a loop, e.g. 1sp2, the cells that form the loop should be removed. Therefore the previous example will yield [1,2].
• Out of bounds indexing will yield the closest index of the indexed item that is a number. E.g. 1,2s should yield [1,2,2]

Answer 3

Internal Truth Machine code-golf

It's a normal truth machine but instead of taking input, it uses the first character of the program. Thus, internal.

Example: 0abcd prints 0 and halts, and 1abcd prints 1 infinitely.

Answer 4

Balanced interval tree code-golf fastest-algorithm

You will write a balanced, online interval tree.

• A function, method, or procedure that performs insertion into a query of intervals that overlap with an interval over a, b in O(log n) time, given that a is less than b, including:
  • intervals that fully enclose a, b
  • intervals fully within a, b
  • intervals that start to the left of a but end before b
  • intervals that start to the right of a but end after b
• A function, method, or procedure that performs insertion ov an arbitrary interval a,b into a data structure in O(log n) time
• Both O-bounds must hold after arbitrary series of insertions and queries

Requirements

If you write non-method functions, your submission may take the data structure as a global variable or receive the data structure as the first parameter.

You must informally prove your submission falls within the required O-bounds or name the data structure your program implements. If the name of the data structure you are implementing is obscure, you may name the paper of the data structure.

This is code-golf, so the submission with the shortest length in bytes wins.

Answer 5

Posted: Find the Inverse Neighbor Pairs code-golfnumber-theory

Answer 6

Recolour my Table (WIP)

code-golfgraphical-output

I have an oak table. It's a very nice oak table. But recently, I've noticed that my table has been getting some sort of white patches on it:

Insert picture of my table here.

Now, I like my table, and I don't want my table getting all dirty. I'm asking y'all to fix this for me, so that my table will once again be clean.

The Challenge

Given a picture of the table in question, replace all pixels that are white with the correct table colour. I know I'll need to specify this area better, but I don't know how to. Suggestions are welcome.

Rules

Unsure

Scoring

This is code-golf, so the answer with the fewest amount of bytes wins.

Answer 7

floating-point error matters

Write a expression of floating-point numbers in any languages. When calculating the expression without floating-point errors (as what a human do), it should be 0. But with floating-point errors (as what happened in your language), it yield 1 instead.

• Floating-point numbers are some numbers which store a finite number digits (binary or decimal or in any other bases) of fraction, plus an exponent in computer. It may be IEEE 754, but not must be.
• Loss of precision due to integer types (which do not has a exponent) are not allowed in the expression. You are still allowed to include integers (or even other types) in your expression as long as operations such as rounding into an integer are not the root of errors.

Shortest codes win as code-golf.

---

Sandbox:

• Is there any duplicates here?
• Is asking for an expression instead of full program allowed?

Answer 8

No title yet.

By Zekendorf's theorem every non-negative integer has a unique representation as the sum of Fibonacci numbers where no two numbers coincide or are adjacent.

In The minimum fibonacci challenge! the challenge was to output the list of Fibonacci numbers. However, you can instead consider the list of coefficients of the sum \$ \small x_0F(2) + x_1F(3) + x_2F(4) + \ldots \$ (since \$ \small F(0) = 0 \$ and \$ \small F(1) = F(2) \$ never appear in the Zekendorf representation) and represent that as a binary number \$ \ldots x_2 x_1 x_0 \$, e.g. \$ \small 67 = \small 1F(2) + 0F(3) + 1F(4) + 0F(5) + 1F(6) + 0F(7) + 0F(8) + 0F(9) + 1F(10) \$ which we can represent using the binary number \$ \small 100010101 \$ or \$ \small 277 \$ in decimal.

We can readily convert the binary representation back into the original integer by calculating the sum of the relevant Fibonacci numbers. However, I would like you to, given an input integer \$ \small n \$, output the decimal integer whose binary representation encodes the Zekendorf representation of \$ \small n \$ in this way.

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

Answer 9

Calculate Mahjong points

Introduction to Mahjong tiles

Mahjong (麻雀) is a board game that originates from China. Mahjong tiles used in this challenge are in Unicode points U+1F000 – U+1F021:

🀀🀁🀂🀃🀄🀅🀆🀇🀈🀉🀊🀋🀌🀍🀎🀏🀐🀑🀒🀓🀔🀕🀖🀗🀘🀙🀚🀛🀜🀝🀞🀟🀠🀡

They are categorized as:

• Winds (風牌): 🀀(East Wind), 🀁(South Wind), 🀂(West Wind), 🀃(North Wind)

• Dragons (三元牌): 🀄(Red Dragon), 🀅(Green Dragon), 🀆(White Dragon)

• Ten Thousands (萬子): 🀇(One of the Ten Thousands) through 🀏(Nine of the Ten Thousands)

• Bamboos (索子): 🀐(One of the Bamboos; note that it depicts a bird) through 🀘(Nine of the Bamboos)

• Circles (筒子): 🀙(One of the Circles) through 🀡(Nine of the Circles)

• Winds and Dragons are together called Honors (字牌).

• Ten Thousands, Bamboos and Circles are each called a suit and together called Numbers (数牌). They have ranks from 1 to 9.

• Among Numbers, the Ones and the Nines are called Terminals (老頭牌). The Twos through the Eights are called Simples (中張牌).

• Honors and Terminals are together called Orphans (幺九牌).

Every Mahjong tiles have 4 copies of themselves.

Mahjong Hand

A legal Hand will be given as the input. It consists of:

• A Head, which is 2 identical tiles.

• 4 Bodies, each which is either:

  • A Sequence, which is 3 consecutive Numbers of the same suit.

  • A Triplet, which is 3 identical tiles.

Hence, a Hand consists of 14 tiles.

There are exceptions. See "Seven Heads" and "Thirteen Orphans" below.

Points

The objective is to calculate how many points a Hand has. Points are gained by having Yakus (役), which are cumulative.

Also I apologize that I named these Yakus to be more intuitive for the code golf, making them differ from the 'usual' names. Sorry!

1 Point Yakus

• Menzen Tsumo (門前清自摸和), which is worth 1 point, will always be assumed.

• Pinfu (平和): Get a non-Dragon Head and 4 Sequences.

  • Example: 🀃🀃🀇🀈🀉🀑🀒🀓🀔🀕🀖🀟🀠🀡

• One Pair (一盃口): Get 2 identical Bodies.

  • Example: 🀂🀂🀂🀇🀇🀇🀈🀉🀓🀓🀔🀔🀕🀕

• Dragon Triplet (役牌): Get a Triplet of Dragons. Multiple Dragon Triplets are cumulative.

  • Example: 🀆🀆🀆🀇🀈🀉🀊🀊🀒🀓🀔🀛🀜🀝

• All Simples (断幺九): Let the Hand consist only of Simples.

  • Example: 🀈🀉🀊🀓🀓🀓🀚🀛🀛🀜🀜🀝🀠🀠

2 Points Yakus

• Seven Heads (七対子): Get 7 Heads. It cannot contain 2 identical Heads.

  • Example: 🀀🀀🀂🀂🀆🀆🀈🀈🀊🀊🀐🀐🀛🀛

• Colorful Sequences (三色同順): Get a sequence for each suit, consisting of the same set of ranks.

  • Example: 🀀🀀🀁🀁🀁🀉🀊🀋🀒🀓🀔🀛🀜🀝

• Full Sequence (一気通貫): Get 3 sequences of the same suit, consisting of ranks of 123, 456, and 789.

  • Example: 🀀🀀🀁🀁🀁🀇🀈🀉🀊🀋🀌🀍🀎🀏

• Semi-Orphans (チャンタ): Let all Heads and Bodies have at least 1 Orphan.

  • Example: 🀀🀀🀁🀁🀁🀇🀈🀉🀐🀑🀒🀡🀡🀡

• Concealed Three (三暗刻): Get 3 Triplets.

  • Example: 🀀🀀🀁🀁🀁🀊🀊🀊🀋🀋🀋🀑🀒🀓

• Colorful Triplets (三色同刻): Get a Triplet for each suit, consisting of the same rank.

  • Example: 🀀🀀🀉🀊🀊🀊🀊🀋🀓🀓🀓🀜🀜🀜

• Dragons Minor (小三元): Let the Head and 2 Bodies consist of Dragons. Cumulative with the 2 Dragon Triplets.

  • Example: 🀄🀄🀅🀅🀅🀆🀆🀆🀊🀋🀌🀒🀓🀔

• All Orphans (混老頭): Let the Hand consist only of Orphans. Supersedes Semi-Orphans. Cumulative with Seven Heads.

  • Example: 🀁🀁🀂🀂🀃🀃🀆🀆🀇🀇🀏🀏🀘🀘

• Three of a Kind (一色三順): Get 3 identical Bodies. Supersedes One Pair.

  • Example: 🀅🀅🀇🀇🀇🀈🀈🀈🀉🀉🀉🀙🀚🀛 (Note that this example also presents Semi-Orphans, which makes it supersede Concealed Three.)

3 Points Yakus

• Two Pairs (兩盃口): Get 2 pairs of identical Bodies. Supersedes One Pair and Seven Heads.

  • Example: 🀃🀃🀇🀇🀈🀈🀉🀉🀑🀑🀒🀒🀓🀓

• Semi-Terminals (純チャンタ): Let all Heads and Bodies have at least 1 Terminal. Supersedes Semi-Orphans.

  • Example: 🀇🀇🀇🀈🀉🀍🀎🀏🀏🀏🀏🀙🀙🀙

• Semi-Flush (混一色): Let the Numbers consist of a single suit.

  • Example: 🀂🀂🀇🀈🀉🀉🀉🀉🀊🀋🀌🀌🀍🀎

6 Points Yaku

• Flush (清一色): Let the Hand consist of a single suit of Numbers. Supersudes Semi-Flush.

  • Example: 🀇🀇🀇🀈🀉🀉🀉🀉🀊🀋🀌🀌🀍🀎

Yakumans

Yakumans (役満) worth 13 points, and supersede all Yakus above. Multiple Yakumans are cumulative.

Without Yakumans, the points are capped at 13.

• Concealed Four (四暗刻): Get 4 Triplets.

  • Example: 🀀🀀🀉🀉🀉🀌🀌🀌🀒🀒🀒🀞🀞🀞

• Thirteen Orphans (国士無双): Collect all 13 Orphans, plus an additional Orphan.

  • Example: 🀀🀁🀂🀃🀄🀅🀆🀇🀇🀏🀐🀘🀙🀡

• Nine Gates (九蓮宝燈): Get Flush of ranks of 1112345678999, plus an additional Number of the same suit.

  • Example: 🀇🀇🀇🀈🀉🀊🀋🀋🀌🀍🀎🀏🀏🀏

• All Greens (緑一色): Let the Hand consist only of Green Dragons and the Twos, Threes, Fours, Sixes, and Eights of the Bamboos.

  • Example: 🀅🀅🀅🀑🀑🀒🀒🀓🀓🀕🀕🀕🀗🀗

• All Honors (字一色): Let the Hand consist only of Honors. Cumulative with Concealed Four.

  • Example: 🀀🀀🀀🀁🀁🀂🀂🀂🀅🀅🀅🀆🀆🀆

• All Terminals (清老頭): Let the Hand consist only of Terminals. Cumulative with Concealed Four.

  • Example: 🀇🀇🀇🀏🀏🀏🀐🀐🀐🀘🀘🀙🀙🀙

• Dragons Major (大三元): Get a Triplet for each of Dragons.

  • Example: 🀄🀄🀄🀅🀅🀅🀆🀆🀆🀇🀈🀉🀑🀑

• Winds Minor (小四喜): Let the Head and 3 Bodies consist of Winds.

  • Example: 🀀🀀🀁🀁🀁🀂🀂🀂🀃🀃🀃🀖🀗🀘

• Straight Flush (連七対): Get Seven Heads with Numbers with consecutive ranks of the same suit.

  • Example: 🀚🀚🀛🀛🀜🀜🀝🀝🀞🀞🀟🀟🀠🀠

• Four of a Kind (一色四順): Get 4 identical Bodies.

  • Example: 🀃🀃🀓🀓🀓🀓🀔🀔🀔🀔🀕🀕🀕🀕

• Winds Major (大四喜): Worths 2 Yakumans. Get a Triplet for each of Winds. Cumulative with Concealed Four.

  • Example: 🀀🀀🀀🀁🀁🀁🀂🀂🀂🀃🀃🀃🀖🀖

• The Septentrions (大七星): Worths 2 Yakumans. Get a Head with each of Honors. Supersedes All Honors.

  • The only example: 🀀🀀🀁🀁🀂🀂🀃🀃🀄🀄🀅🀅🀆🀆

Other rules about Mahjong

When a Hand can be interpreted as different combinations of Heads and Bodies, the combination with the most points will be chosen. (See Three of a Kind and Two Pairs above)

Examples

🀅🀅🀋🀋🀌🀌🀍🀍🀑🀒🀓🀟🀠🀡 : Menzen Tsumo + One Pair = 2 points.

🀉🀊🀋🀌🀍🀎🀑🀒🀓🀔🀔🀞🀟🀠 : Menzen Tsumo + Pinfu + All Simples = 3 points.

🀀🀀🀀🀁🀁🀁🀂🀂🀂🀃🀃🀃🀆🀆 : Winds Major + Concealed Four + All Honors = 52 points. (Most points possible)

Rules about code golf

• Input type and format doesn't matter, but it must consist of the Unicode characters above. In C++, valid examples include std::u8string (sorted or not) and std::multiset<u32char_t>.

• Output type and format doesn't matter either.

• Invalid Hands (not exactly 14 tiles, contains 5 copies of the same tile, etc) fall into don't care situation.

• If and only if your language doesn't support Unicode, use the following table to parse Mahjong tiles:

         |x0|x1|x2|x3|x4|x5|x6|x7|x8|x9|xA|xB|xC|xD|xE|xF  
  -------+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--
  U+1F00x|We|Ws|Ww|Wn|Dr|Dg|Dw|T1|T2|T3|T4|T5|T6|T7|T8|T9
  -------+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--
  U+1F01x|B1|B2|B3|B4|B5|B6|B7|B8|B9|C1|C2|C3|C4|C5|C6|C7
  -------+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--
  U+1F02x|C8|C9|
  

Answer 10

Be second to last

This is a king-of-the-hill challenge with a game with a clear winning strategy, but the winner is not the one who comes in first, but the one who comes in second to last! While losing is easy (just throw every game), just barely not losing is quite a task.

The Game

The bots will be made to play games of normal Nim against each other. The rules are as follows:

• The board consists of a list of unsigned integers
• In alternating turns, the players reduce one non-zero element by an amount of their choosing, as long as the element is not negative afterwards
• The player who reduces the list to all entries being 0 wins

The length of the Nim list and its entries will be randomly determined for each game.

The Tournament

All bots will compete against each other in a Danish-Style tournament:

• Initially, players are assigned positions in a list randomly
• After each round, the list is sorted by the amount of wins with an order-preserving method
• In each round, the players with the odd numbers play against those with the following even numbers (so 1st against 2nd, 3rd against 4th, and so forth)
• If the number of players is odd, the one in the middle position has a bye and is given 1 win without playing.
• The tournament ends after \$\lceil \log_{2}(N_{Players}) \rceil\$ (Binary logarithm of the number of players, rounded up) rounds.

The player in the second to last position of the list counts as the total winner of the tournament.

King of the Hill

Each time the contest is run, 100 tournaments are played. The bots with the highest number of being second to last is the overall winner.

Challenge Rules

• Each bot is a Python 3 class implementing the following functions:
  • __init__(ID, n) passes the bot its randomly assigned ID for this tournament, and the total number of players.
  • nim(self,list) which takes in the Nim board state and returns a tuple (index, amount), specifying from which list index to subtract what number. This function is repeatedly called during each game of Nim played, until a winner has been determined.
  • rank(self,IDs,scores) which takes in the current order of ranking in the tournament, and the list of scores of each bot, ordered by ID. It returns nothing. This will be called for each bot after each round of tournament, as well as before the first round, to provide the ranking information if the bot requires it.
• Bots are explicitly allowed to implement further functions and store data for private use. Bots will only be deleted and re-initialized after each full tournament.
• Programming meta-effects are forbidden, meaning any attempts to directly access other bots' code, the Controller's code, causing Exceptions or similar. Any bot doing so is disqualified until fixed.
• The following will also be set up to cause Exceptions:
  • nim returning an index of which the element is already 0
  • nim return an amount larger than the element at that index
• Other languages are allowed only in case they can be easily converted to Python 3.
• Class names have to be unique
• Multiple bots per person are allowed, but only the latest version will be taken of iteratively updated bots.
• As per Standard Loopholes, copies of bots are not allowed. This includes bots who differ from other bots only by a trivial change in strategy (e.g. a change in the pseudorandom seed).

Controller and Examples

Watch this space.

Answer 11

Find the most important character

code-challengerestricted-sourcestring

The challenge is to write a program that outputs the most occurrent non-trivial* character in the input string, excluding these bracketing characters ()[]{}. A solution is scored by feeding the program's source into its input. Bracketing characters are allowed in the program, but may not be selected by the program as the most occurrent character. In cases where letters have the same percentile score, any of the characters can be returned, or all of them.

Write a program that has a maximal percentage of a single non-trivial* character, excluding these bracketing characters ()[]{}. Bracketing characters are allowed, but may not be selected as the highest-percentage character. Answer is scored as by running the program, with the program's source as its own input. In cases where letters have the same percentile score, any of the characters can be returned, or all of them.

*Non-trivial is defined in this case to be a character that contributes to the functionality of the program. If the character can be removed without influencing how the program runs, it is a trivial character.

Scoring

Score is determined as follows:

$$(\frac{n_{char}}{n_{total}}) * 100\% $$

With n_char being the number of occurrences of that character in the input, and n_total being the total number of non-trivial characters in the input. With this scoring criteria, all scores should be within the range (0,100]

Highest scoring solution per language wins.

Input

Solutions should take in any valid string as input. Scoring is done using the program's source code as input(with all non-trivial charcters removed).

Output

A single character with the highest percentage occurrence. Each solution should be capable of outputting standard ASCII, as well as the language's codepage (if applicable).

Errata

Creative solutions are encouraged. Boring solutions with long padded strings substituted in for numbers are discouraged. Standard loopholes are disallowed.

Examples

Program:

aabbbc

Output:

b

---

Program:

aabb

Output:

a or b or ab

Answer 12

Shift the digits code-golf integer arithmetic restricted-time

Here, x (supplied as input) and n (the result of your computation) are both positive integers. n * x = n shifted. Find n.

Here's an example of shifting:

123456789 -> 912345678
abcdefghi -> iabcdefgh (letters = any 0~9 digit)
123       -> 312

Rules

• Preceding zeros count after shifting. If the number is 10 and is multiplied by 0.1 (0.1 isn't a valid input), the result is 1, which isn't equal to 01 (10 after shifting).
• Your code has to run on Try It Online without timing out.
• If your number only has one digit, the shifted result is your number:

1 -> 1
4 -> 4
9 -> 9

Test cases

Just to show that it's possible ...

9 -> 10112359550561797752808988764044943820224719
(In this test case, x = 9 and n = 10112359550561797752808988764044943820224719.
n shifted = n * x =              91011235955056179775280898876404494382022471)

Don't believe it? Try it online.

Answer 13

Posted here

Answer 14

Approximate Alternating Triangles

Answer 15

Japanese Encoding Conversion code-golfencoding

Answer 16

Answer 17

Making Minimial Memory Masterpieces

In this challenge you will be asked to write a small computer program to paint an approximation of the painting Fine Wind, Clear Morning.

Your submission

In this challenge we are going to start with a blank canvas. We are going to add an "ant" in the top left corner. You will be telling the ant how to paint the picture by writing its brain.

An ant is a simple creature, at a given time it knows two things.

• Some memories that it has

• The color of the pixel it is currently standing on

And at every step the ant consults these two things it knows and then

1. Draws one pixel of any color where it is standing

2. Moves one pixel in a cardinal direction

3. Replaces its all of its memory

The ant can thus be thought of as a function which takes a color and a value and spits out a color, a value and a cardinal direction.

For example here is the brain of an ant that draws a zigzag pattern in red

\$ f(c,m) = \left\{\begin{matrix}(\mathrm{Red}, & \mathrm{South}, & 1) & \mathrm{if} & m = 0\\ (\mathrm{Red}, & \mathrm{East}, & 0) & \mathrm{if} & m = 1\end{matrix}\right. \$

However our canvas is not infinite, so this ant would run into a border eventually. We will stop the ant if it tries to move off, by canceling its move and leaving it on the square it is on. You are free to use this behavior to your advantage.

The one issue here is that currently the ant will never stop, it will just keep painting forever. Which is why ants come with a builtin kill switch. When an ant's memories are equal to an exact value the ant explodes or something, ending the drawing.

Your submission will thus consist of 3 things

• The starting memory for your ant

• A description of the ant's function (more on this later)

• The ending memory for your ant

Scoring

The goal of this challenge is to have the ant that requires the least memory to operate. We will count this by the number of different states your ant's memory can have.

Thus to score your answer you should run it on the canvas provided. Once the ant has finished your score will be the total number of distinct memories used by your ant through the process. We will include the initial memory even if it does not appear again, but you should not count the ending memory (the one that kills the ant).

The lowest score will be the winner.

The painting

The painting will be a low resolution version of the one from the wikipedium. It will use 3 bit color resolution.

I will decide on the exact specific sizes and make the image in a bit.

A valid answer must produce this image exactly when run on the canvas.

Verification Tool

I will make a tool for running and verifying programs, using a standardized format. It will be runnable in browser.

Answer 18

Answer 19

How many balloons do I need in each corner?

Posted

Answer 20

Bot Factory

Main Post

Answer 21

Golf yourself a real calculator [draft] code-golf arithmetic

We will only cover the characters(0123456789+-*/=%ñ) in our tutorial.

The = operations

Unlike most desktop calculators, our household calculator is a tacit language. Therefore it is able to do a lot more than other infix calculators.

Take a simple calculation as an example. The non-scientific calculator does not have the exponentiation operator. What do you do to calculate 2^5?

2*2====

However, there's a shortcut for doing that. Since 2 is already in the expression buffer, you can simply do

2*====

The calculator automatically fills in the current expression during the inputting.

Here is a demonstration of how this works:

(A template for easy copy&paste.

Pressed Key      : 
Expression buffer: 
Output buffer    : 
)

Pressed Key      : 2
Expression buffer: 2
Output buffer    : 2

Pressed Key      : *
Expression buffer: 2 *
Output buffer    : 2

Pressed Key      : =
Expression buffer: * 2
Output buffer    : 4

Pressed Key      : =
Expression buffer: * 2
Output buffer    : 8

Pressed Key      : =
Expression buffer: * 2
Output buffer    : 16

Pressed Key      : =
Expression buffer: * 2
Output buffer    : 32

Implicit 0 before calculation

Suppose you enterede the following expression:

*1

Now, don't get me wrong, the household calculator of course doesn't have pointers. So, why doesn't it raise a syntax error though? (The output is 0 by the way.) Here's why.

The calculator initially has the expression starting at 0, therefore it prepends a 0 to the expression. Therefore the full form of our expression is:

0*1

What we've learned so far

• The output buffer is a part of the calculator storing the latest-evaluated integer. All entered numbers get appended to the output buffer as well as the expression buffer.
• The expression buffer is a part of the calculator storing the latest instruction. After a = operator, it stores the latest applied expression for later application.
• The = operator tries to evaluate the instruction buffer. If that's a syntax error, it tries to evaluate that concatenated the output buffer. If that still fails, it tries to evaluate the output buffer concatenated with the instruction buffer. After that operation, the expression starting from the newest-entered dyadic operator is saved in the expression buffer.

Answer 22

Mimic the X11 Primary selection code-golf

Background

In X11 (a windowing system used by a lot of Unix-like OS), what you would call the clipboard behave a bit differently than on other OSes like MacOS or Windows. While the "traditional" clipboard using ctrl+v/ctrl+c works, there is also another clipboard, called PRIMARY selection, that behave as following:

• when you select a piece of text, this selection is added to the clipboard
• when you use the middle mouse button, the content of that selection is pasted where your mouse is.

Some more details for those who are interested : X11: How does “the” clipboard work?

Challenge

The input in this challenge is any representation of a binary input. In the following I will use 'S' for select and 'P' for paste.

Given the input, you must output the input after making the following changes :

• put the content of the current output in the primary selection when you receive a select instruction
• paste the content of the primary selection in the middle of the current output when you receive a paste character. If the current output is odd numbered, the middle is the length divided by 2 and truncated.

Example

Input is SPSP :

selection = ""
output = "SPSP"
 SPSP
↑

selection = "SPSP"
output = "SPSP"
 SPSP
 ↑

selection = "SPSP"
output = "SPSPSPSP"
 SPSP
  ↑

selection = "SPSPSPSP"
output = "SPSPSPSP"
 SPSP
   ↑

selection = "SPSPSPSP"
output = "SPSPSPSPSPSPSPSP"
 SPSP
    ↑

Final Output is SPSPSPSPSPSPSPSP

Test Cases

"" -> ""
"S" -> "S"
"P" -> "P"
"PS" -> "PS"
"SP" -> "SSPP"
"SPP" -> "SSPPSPPPP"
"SPSP" -> "SPSPSPSPSPSPSPSP"
"SPPSP" -> "SPSPPSPSPSPPSPPSPSPPSPPSPSPPSP"
"SPPSPSSS" -> ""SPPSSPPSSPPSSPPSSPPSSPPSPSSSPSSSPSSSPSSSPSSSPSSS

Reference Implementation

In Python 3 :

def clipboard(inp, select="S", paste="P"):
    out = inp
    primary_selection = ""
    for instruction in inp:
        if instruction is select:
            primary_selection = out
        if instruction is paste:
            out = out[:len(out)//2] + primary_selection + out[len(out)//2:]
    return out

Try it online!

Rules

• You may assume that the input contains only the "paste" or "select" characters (you don't need to handle error cases)
• You may use any kind of data representation (e.g binary data is allowed.)
• Standard code-golf rules , shortest submission by bytes wins!

Answer 23

Four Divisors

Given an integer array nums, return the sum of divisors of the integers in that array that have exactly four divisors.

If there is no such integer in the array, return 0.

Test Case 1:

Input: nums = [21,4,7]
Output: 32
Explanation:
21 has 4 divisors: 1, 3, 7, 21
4 has 3 divisors: 1, 2, 4
7 has 2 divisors: 1, 7

The answer is the sum of divisors of 21 only.

Please feel free to add more test cases.

This is code-golf so shortest submission in bytes wins! If you liked this challenge, consider upvoting it... And happy golfing!

Answer 24

RRE numbers code-golf decision-problem number string

Given a single floating-point number (which can potentially be taken as a string), output whether this decimal is an RRE number.

RRE complement for the input number

Say your input is 3.14.

1. Replace the decimal point by the fraction bar. 3/14
2. Reciprocal the fraction. 14/3
3. Evaluate the fraction. 4.666...
4. Round the decimal point to the same length as the input. 4.67
5. If the absolute difference between the input and the output is below 2, it's an RRE number. Otherwise, it isn't an RRE number.

Specification

1. Programs are allowed to give wrong output if the absolute difference is very close to 2.
2. The integral part of the decimal is always nonzero.
3. Truthy/Falsy outputs follows the language's convention, or exactly one value for truthy and another for falsy.

Test cases

Here is a sample program I use to generate the test cases.

1.0     -> True
2.9     -> True
3.14    -> True
50.2501 -> True
2.14    -> False
2.11111 -> False
3.1     -> False
51.123  -> False
51.51   -> False
24.12   -> False

Answer 25

Mom-rounding the time code-golf time arithmetic integer

Context

Growing up with my mother, whenever she looked at a clock to check the time, she would always say "shoot, it's already X!" and then I would look at the clock and realize she was just rounding the time in a really weird way.

Task

Given a time with hours and minutes, round it like my mom would. Rounding always occurs upwards. Say it is currently H hours and M minutes.

• if M is 0, no rounding occurs; my mom isn't that crazy;
• if M is 9 or less, my mom rounds to H:15;
• if M is 19 or less, my mom rounds to H:30;
• if M is 34 or less, my mom rounds to H:45;
• for any other value of M, my mom rounds to H+1:00.

Input

You will take a time that needs rounding, in any sensible format. ISO strings for date/time, two integers representing hours/numbers, a string with two integers and a separator; these are all fair game.

Output

The string "shoot, it's already X" with X replaced with the mom rounding time.

Scoring

This is code-golf so shortest answer wins. However, if your source code contains the substring shoot, it's already then you may subtract 19 from your score.

Test cases

Here is the program I use to generate the test cases.

11:00 -> shoot, it's already 11:00!
 3:08 -> shoot, it's already 03:15!
 1:09 -> shoot, it's already 01:15!
13:13 -> shoot, it's already 13:30!
 2:35 -> shoot, it's already 03:00!

Answer 26

Bit delivery in Bin City code-golf binary

Story

Similar to a newspaper route you have been tasked with delivering bits to the residents of Bin City. Just as certain people like certain newspapers, the citizens of Bin City prefer either \$1\$s or \$0\$s delivered to their doorstep. Unfortunately, your new boss has arranged the deliveries in an awkward manner.

The residential streets of Bin City all have multiples of \$8\$ houses. So naturally, your delivery routes are organised as a series of one or more bytes. Your boss has laid out the deliveries as follows: first off, start at the house at the beginning the street on the left-side, followed by the house opposite on the right-side of the street, then the next house after the first one on the left-side of the street, then the one opposite it on the right-side, &c. The \$1\$s and \$0\$s to be delivered along this route are stored, in order, in the bits of the bytes.

Task

You've quite rightly deduced it would be far easier an more time effective to deliver the bits starting from the first house on the left-side of the street and continue on delivering bits up the left-side to the end. Then cross the street to the house opposite on the right-side and continue on down the right-side back to what would have originally been your second delivery at the end.

Illustration for eight houses (one byte)

The original input route is on the far left next to the byte containing the bits to be delivered along that route. Beside it, to the right, is the output byte with the bits rearranged for the new improved delivery route on the far right.

Input and output

The input will be between \$1\$ and \$8\$ bytes long, organised by your boss in a back-and-forth left-side to right-side manner as above. This can be in any convenient byte-wise way (eg not a list of bits, but a list of bytes, words, or double-words &c is ok). A 64-bit integer along with the bit-length is ok too. A bit-length will be needed for any structure using elements larger than a byte. The order can be in any convenient bit-wise way (i.e. least-significant to most-significant bit or vice versa) and any convenient byte-wise way (eg first element in a byte list to last or vice versa, least--significant to most-significant byte or vice versa in a list or words or double-words &c traversed first to last or vice versa) so long as the output follows the same convention. The output must use the same structure and ordering convention as the input but with the bits rearranged to be up the left-side then back down the right-side in the manner described above.

Please state your bit-wise and byte-wise ordering as well as your i/o structure.

Scoring and winning criterion

Standard code-golf rules apply. Shortest code in bytes wins.

Test cases

As lists of bytes ordered least-significant bit to most-significant bit and first byte to last byte in the list.

[85] -> [15]
[85, 85] -> [255, 0]
[85, 85, 85] -> [255, 15, 0]
[85, 85, 85, 85] -> [255, 255, 0, 0]
[85, 85, 85, 85, 85] -> [255, 255, 15, 0, 0]
[85, 85, 85, 85, 85, 85] -> [255, 255, 255, 0, 0, 0]
[85, 85, 85, 85, 85, 85, 85] -> [255, 255, 255, 15, 0, 0, 0]
[85, 85, 85, 85, 85, 85, 85, 85] -> [255, 255, 255, 255, 0, 0, 0, 0]
[170] -> [240]
[170, 170] -> [0, 255]
[170, 170, 170] -> [0, 240, 255]
[170, 170, 170, 170] -> [0, 0, 255, 255]
[170, 170, 170, 170, 170] -> [0, 0, 240, 255, 255]
[170, 170, 170, 170, 170, 170] -> [0, 0, 0, 255, 255, 255]
[170, 170, 170, 170, 170, 170, 170] -> [0, 0, 0, 240, 255, 255, 255]
[170, 170, 170, 170, 170, 170, 170, 170] -> [0, 0, 0, 0, 255, 255, 255, 255]
[208] -> [28]
[96] -> [40]
[155, 36] -> [37, 210]
[232, 33] -> [24, 114]
[174, 18, 247] -> [66, 191, 248]
[130, 143, 125] -> [48, 111, 157]
[76, 181, 117, 107] -> [122, 159, 46, 67]
[158, 238, 106, 124] -> [166, 232, 230, 223]
[233, 87, 232, 152, 182] -> [249, 72, 182, 117, 120]
[142, 61, 195, 199, 218] -> [114, 185, 220, 153, 214]
[107, 131, 170, 25, 103, 171] -> [25, 80, 27, 175, 244, 233]
[71, 41, 113, 118, 202, 26] -> [27, 237, 72, 220, 42, 134]
[30, 226, 236, 110, 111, 211, 202] -> [134, 170, 219, 216, 233, 126, 203]
[162, 53, 89, 29, 128, 172, 134] -> [112, 125, 32, 146, 23, 68, 178]
[112, 71, 252, 192, 100, 176, 108, 71] -> [188, 142, 74, 186, 104, 35, 113, 40]
[111, 58, 224, 222, 231, 246, 214, 200] -> [75, 232, 235, 142, 149, 187, 61, 238]

Reference implementation in Python.

---

Sandbox: Is this a duplicate? Is it clear enough? Are the i/o restrictions reasonable?

Answer 27

Answer 28

\$\Theta(N\cdot\sqrt N)\$ sort code-golf restricted-complexity array-manipulation

The challenge is to write a program that sorts an array of distinct positive integers in ascending order. You may input the array and output the result using the default IO methods.

However, the worst-case time complexity of the algorithm used must be \$\Theta(N \cdot \sqrt N)\$, where \$N\$ is the length of the input array.

You may not assume your built-in sorting functions to have any time complexity in particular. While you can implement a fast (e.g. \$O(N \log N)\$) sort and then perform pointless operations to increase the complexity, direct algorithms exist.

This question is tagged code-golf, so the shortest code wins!

Sandbox stuff

I have noticed that a possible solution is, for example, to create a sorted multiset from the array and read it back. I would probably like to disallow that. Is there a way to achieve that without making the validity criteria subjective?

Answer 29

How Many Ways To Empty The Glove Box?

Posted

Answer 30

How could these rep and scores have happened?

code-golf arithmetic integer

Challenge: Given a reputation score, a count of questions with accepted answers, and a list of net votes on questions, calculate a sequence of actions that could have produced them. To keep this simple, here's a few simplifications from how Stack Exchange actually works:

• The only things that change reputation are upvotes on questions (+10), downvotes on questions (-2), and accepting an answer to a question (+2).
• The daily cap of 200 never comes into play.
• Votes are never retracted and accepts are never rescinded.

The minimum possible reputation of 1 still applies. If there are multiple sequences of actions that can produce the given state, then your program/function should return the shortest possible sequence (or one of the shortest, if there's multiple that are tied for the shortest). If there are no sequences of actions that can produce the given state, consider that Undefined Behavior, so it doesn't matter what your program does.

Examples/test cases:

• A user has 1 reputation, hasn't accepted any answers, and has no questions. The shortest possible sequence is "".
• A user has 33 reputation, has accepted 1 answer, and has questions with scores 2 and 1. A shortest possible sequence is "upvote, upvote, upvote, accept".
• A user has 3 reputation, hasn't accepted any answers, and has a question with score -5. The shortest possible sequence is "downvote, downvote, upvote, downvote, downvote, downvote, downvote".

The standard restrictions against loopholes apply. I/O may be in any convenient format. Examples: For input, [101,0,4,3,2,1] or (101,0,[4,3,2,1]) could mean a user with 101 reputation, 0 questions with accepted answers, and questions with scores 4, 3, 2, and 1. For output, the string UDA could mean "upvote, downvote, accept".

This is code golf, so the shortest program/function wins.