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

Locate Substring

This is not a challenge yet, just a place to write down an idea.

Given some finite binary string \$S\$, we can try to find the minimal length \$n \in \mathbb N\$ such that we can uniquely locate each contiguous substring \$ T \$ of \$ S \$ that has length \$ n \$.

Example

Let \$ S = 01000110 \$. Then surely \$ n > 1\$. But we also immediately see that \$ n > 2\$ because for instance the substring \$T = 01\$ appears twice in \$ S = \color{red}{01}00\color{red}{01}10\$. But all substrings of length \$ n=3 \$ are distinct, these are in fact (in the order they apppear from left to right) \$ \{ 010, 100, 000, 001, 011, 110 \} \$. This means that \$ n=3 \$ is minimal. [end of example]

Alternatively given some \$ n \$ one might ask to find the longest sequence \$ S \$ such that all substrings \$ T \$ of length \$ n \$ are uniquely locatable.

Answer 2

Order times fully written out in English, alphabetically

A 12h format time of day can be fully written out in English according to the following rules:

1. a word from one to twelve;

2. a space;

3. optionally a word from one to fifty-nine followed by a space;

4. the "word" AM or PM.

Examples:

 1:31 AM  => "one thirty-one AM"
11:12 PM  => "eleven twelve PM"
 4:00 AM  => "four AM"

Challenge

The challenge is to take a list of 12h format times and order them alphabetically by the way they are fully written out in English.

Input and output format is flexible. Output can either be the times themselves or their fully written out in English versions.

This is code-golf. Shortest in bytes for each language wins. Standard loopholes forbidden.

Test cases

[ "1:31 AM", "11:12 PM", "4:00 AM" ]   =>   [ "11:12 PM", "4:00 AM", "1:31 AM" ]

More test cases can be added if there is interest.

I'm mainly concerned this might be a dupe. I couldn't find one.

Answer 3

Edit distance for sparse strings

The input to this challenge will be two strings of length one million each. Each string contains only zeros and ones. However each string will contain at most 100 ones and so will be represented by a sorted list of integers. The integers will indicate where the ones are.

Example of input

[ 42394, 108181, 154190, 217161, 301607, 379951, 412651, 623862, 624712, 783863]
[ 42393, 108181, 154189, 267161, 301608, 379951, 412651, 623862, 624713, 783863]

We want to compute the Levenshtein distance between these two strings. However, the standard algorithm will take around 10^12 time which is too slow.

Task

Your code should take in the two inputs and output the edit distance between the two strings. The only restriction is that your code must be fast enough (and not use too much memory) so that it will complete in less than a minute on a standard desktop PC. In case of doubt, I will test the code on my 8GB AMD processer PC using test inputs that I will create.

Small test cases

To test your code here are some small inputs for strings of length 100 with up to 10 ones.

This pair gives edit distance 8.

[18, 23, 30, 40, 47, 53, 60, 73, 89, 94]
[21, 23, 39, 48, 53, 59, 60, 89]

This pair gives edit distance 8

[19, 25, 26, 40, 43, 62, 74, 75, 85, 89]
[10, 26, 27, 28, 44, 70, 74, 75, 76, 86]

This pair gives edit distance 7

[ 9, 17, 18, 29, 45, 50, 57, 64, 80]
[ 2, 16, 23, 27, 32, 43, 49, 56, 63, 79]

This pair gives edit distance 6

[ 3,  9, 12, 33, 39, 49, 55, 72, 84, 94]   
[ 3,  9, 29, 40, 41, 72, 84, 94]

code-golf

Answer 4

Make a reversible formula

For the purposes of this question:

1. a basic formula \$ y = f(x) \$ takes one of the following forms:

$$ x \\ g(x) + c \\ c + g(x) \\ g(x) - c \\ c - g(x) \\ g(x) c \\ c g(x) \\ \frac {g(x)} c \\ \frac c {g(x)} $$

where \$ g(x) \$ is a basic formula;

2. a reversible formula \$ y = f(x) \$ takes one of the following three forms:

$$ \begin{align} y = x & \implies x = y \\ y = c - g(x) & \implies x = g^{-1}(c - y) \\ y = \frac c {g(x)} & \implies x = g^{-1} \left ( \frac c y \right ) \end{align} $$

where \$ g(x) \$ is a reversible formula whose reverse is \$ g^{-1}(x) \$ according to the above rules and \$ c \$ is a non-negative integer. A simple example of a reversible formula would be the expression \$ y = \frac 1 {1 - x} \$ whose reverse is \$ x = 1 - \frac 1 y \$.

Your challenge is to take a basic formula and express it as a reversible formula. The following transformations are allowed:

$$ \begin{align} \left . \begin{array}r x + c \\ c + x \end{array} \right \} & \implies c - (0 - x) \\ x - c & \implies 0 - (c - x) \\ \left . \begin{array}r x c \\ c x \end{array} \right \} & \implies \frac c {\frac 1 x} \\ \frac x c & \implies \frac 1 {\frac c x} \end {align} $$

(Note that the strict domain of the resulting formula may exclude some values not excluded in the original formula, but the limit of the formula should be equivalent to the original formula.)

Of course we're dealing in string equations so you'll be using * and / instead. Examples:

(x + 1) * 2 => 2 / (1 / (1 - (0 - x)))

x * 2 + 1 => 1 - (0 - 2 / (1 / x))

Do not include extraneous parentheses in your result.

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

Answer 5

Should I index like this or like that? code-golf integer decision-problem

Challenge

Let's take a 0-indexed array of length \$l\$. You can index into it with \$i\$, where \$-l\le i<l\$, and the returned element is the element in position \$[i<0]\times l+i\$ (\$[\dots]\$ is the Iverson bracket).

In some cases, it's shorter to use a negative index instead of a positive one, counting the minus sign and the digits as bytes. For example, if we want the \$102\$th element of an array with \$104\$ elements, indexing with \$101\$ and \$-3\$ will both give the same result. However, if we write the numbers in code, 101 is 3 bytes long, while -3 is 2 bytes long, so we prefer -4. In other cases, using a negative index is counterproductive (for a code golfer). Such an example is the will to obtain the \$4\$th element of a \$10\$-element array. In this case, we can use \$3\$ and \$-7\$, but -7 is longer than 3, so we'll choose 3 instead.

Given two inputs \$l\$ and \$i\$, where \$l>0\$ (it doesn't make sense to index into an empty array) and \$0\le i<l\$ (or \$-l\le i<0\$, be consistent), your job is to determine whether positive or negative indexing is better for code golfing purposes. In case both are of the same length, you may return either decision, even inconsistently. The returned value must be one of two distinct and consistent values, defined by the answerer.

Of course, using standard loopholes isn't fun, so, if you do use any, then, sorry, your answer isn't valid. ;-)

Test cases

Here, 1 is used for negative indexing and 0 for positive. I also always prefer using positive indices, but you may prefer otherwise.

l     i           (actual index)
----- ----- ----- -----
    1     0     0     0
   10     9     0     9
 1000   999     1    -1
10000  9755     1  -245
  101   100     1    -1
  150   141     1    -9
  150   140     0   140

Answer 6

Fuzzy Circles

Edit

I don't actually like this challenge all that much. Anyone who wants it can have it, else I'll get rid of it.

Background

For a real number x, let ⌊x⌋ be the greatest integer less than or equal to x.

Challenge

Given an input n, find the minimum radius of the circle such that all points that satisfy the following equation are on its interior or border.

⌊x⌋^2+⌊y⌋^2 = n

Input: A real number n

Output: A real number representing the radius of the smallest circle that contains in its interior or border all points that satisfy ⌊x⌋^2+⌊y⌋^2 = n.

Note: The precision expected in this challenge is two decimal places, both for the input and output.

This is a code-golf challenge.

Test Cases (More to be added):

25->5.70

Answer 7

Knightmare in 1024 bytes of (JavaScript?)

king-of-the-hill javascript grid board-game

---

Board

The board is a 16x16 grid of squares. It does not wrap, so the outer edges are an impassable boundary.

Pieces

Each piece is like a Chess knight, and will be referred to as a knight. It moves to a square that is two squares away horizontally and one square vertically, or two squares vertically and one square horizontally.

A knight can move to any of these squares, regardless of whether it is occupied. There is no limit to how many knights may occupy the same square at the same time.

Players

This is a 2 player game. Each player has 16 knights. Knights cannot be removed from the board so there will still be 16 knights per player at the end of the game.

Turns

Each turn both players move all 16 of their knights simultaneously (that is, all 32 knights move at the same time).

Costs

Each square has a cost, which is a non-negative integer, initially set to zero. Each time a knight visits a square, the cost of that square is increased by 1. To be explicit, if N knights land on a square in the same turn, that square's cost is increased by N.

Penalties

After each turn, each knight incurs a penalty, which is the cost of the square it occupies, plus the number of other knights occupying the same square (regardless of whether they are friend or foe).

The player's cumulative penalty is zero at the start of a game, and is increased by each knight's penalty each turn (for all 16 of its knights).

Winning

A game ends after 1024 turns. The winner is the player with the lowest cumulative penalty.

Input

The player is supplied with:

• an array showing the cost for each square
• an array showing the number of its own knights for each square
• an array showing the number of its opponent's knights for each square
• an array showing the total knights for each square
• an array of coordinates for its own knights
• an array of coordinates for its opponent's knights
• its own cumulative penalty
• its opponent's cumulative penalty
• the turn number

Output

The player responds with a move for each of its 16 knights. Each move is a number from 0 to 7, indicating the direction to move, numbered clockwise from the top. The response must be received within 5ms.

Invalid moves

Since the edge of the board is impassable, sometimes there will be fewer than 8 valid moves available for a given knight. If an invalid move is given, it will be reflected vertically and/or horizontally to give a valid move, and that move will be made instead. This means every knight will move every turn - none will ever stand still.

Code

Each entry provides the body of a JavaScript function that is no more than 1024 bytes.

---

Sandbox questions

• I'm not settled on which language to use yet. I like the idea of using a different language for each KotH. I'm considering maybe Japt or APL for this one. Ideally something terse since golfing is part of the challenge here.
• Fixed starting configuration (for example, players in a line along opposite edges of the board), or random initial placement?
• Leaning towards a board that does not wrap. Any reasons to avoid this?
• I've put placeholder values for the number of bytes, the size of the board, and the number of knights per player. Any feedback on how to improve these values welcome.
• I'm not sure whether to make staying still a valid move. I'd prefer to keep it simple and have 8 possible moves with no possibility of staying still.
• I'm currently deciding between the penalty being the cost plus the number of other knights on the same square, or the cost times the number of knights on the square.
• I need to settle on input and output that are suitable for both golfing the contestant code and keeping things running reasonably quickly.

Answer 8

Golf me some Golf

code-challenge game

Write a program to play Golf solitaire!
(I'm somewhat surprised that I haven't seen this pun yet.)

How to play

Golf uses a standard 52 card deck. Play begins with 7 stacks of 5 cards each, one card forming the foundation, and the remaining 16 cards forming the stock. There are two legal moves:

• Move a card from the top of a stack to the foundation (must be one rank higher or lower)
• Draw the top card of the stock and place it on the foundation

The number of cards remaining in the tableau when you run out of moves is your score, with zero being a perfect game.

To make things easier, queens may be played on kings, and aces and kings can be played on each other. Also, while the stock is normally face-down, you will be able to read it all at once.

Rules

The input to your program will be 7 lists of 5 cards representing the tableau (with the last cards on top) plus 1 list of 17 representing the stock (the last card being the foundation). These lists can be flattened as desired (you can take 1 list of 35 and 1 list of 17, or just 1 list of 52). Cards are represented as numbers 0-12.

Your program should output a list (or string) of numbers 0-7 representing the moves in a game of Golf. The numbers 0-6 represent playing a card from a column to the foundation, and 7 represents drawing a card from the stock. Any illegal moves (including playing from an empty column or stock) will disqualify your program.

Your score is the number of bytes in your program plus 2 bytes per card left on the stock after running through the 18 games in the scoring set. The program with the lowest score wins.

Test cases

Example output: (coming soon)

Scoring set: (coming soon)

All games in the scoring set are solvable.

---

Sandbox questions:

• Is code-golf appropriate for this scoring metric, or would code-challenge be more appropriate?

• Should I do away with the scoring metric, and just require the games to be solved completely?

• Would it be more interesting to include some unsolvable games in the scoring set to make programs handle that case gracefully?

Answer 9

Permutation Encoding

Now posted to the main site. Check the revisions log if you want to see the WIP versions.

Answer 10

Distinct Dice Sum Algorithm

From a puzzle on Brainden. Paraphrasing,

What is the best set of 8 sided dice, each identical, such that 3 dice can generate 120 distinct sums? "Best" means the minimum highest sided die configuration.

With 7 sided dice, the best possible sides for each (identical) die is: 1, 2, 8, 51, 60, 79, 83.

For the sake of discussion, use sides=s, and dice=d.

Note1: 120 is the maximum number of distinct sums with s=8, d=3. The formula is:

$$ \frac{(s+d-1!)}{(s-1)!(d)!} $$

Similarly, for s=7, d=3, the formula gives 84. And brute force shows that a side of at least 83 is required for this easier problem.

Note2: The lowest numbered side is always 1 for an optimal solution to the original question. (See comments.)

My question is, "What's the fastest algorithm to discover the minimum highest sided die for maximum distinct sums?".

Specifically, is there some existing algorithm, or better yet, formula, for the minimum highest sided die? For determining all sides?

While there are obvious choices for languages, I'm not interested in that. I'm interested in the best algorithm possible in general. A sketch of the algorithm with the best (smallest) Big-O score wins.

Complexity of answers should be expressed by Big-O notation, e.g., M(s) = O(???), with d=3. Ties will be broken according to number of dice, i.e., M(s,d) = O(???).

As a puzzle toy to idle time some years ago, I wrote a brute force solver. Unfortunately, for (s=8, d=3), and even knowing an upper limit, my program never completed the search (uptime was an issue).

Answer 11

What is the simplest reversible circuit that computes conjugacy of transpositions?

math,permutations,logic-gates

Motivation

Reversible computation refers to computation in which little or no information is deleted. Reversible computation a major component of quantum computation, and reversible computation is potentially many times more energy efficient than conventional computation. I want to know how easy it is to compute the conjugacy of transpositions reversibly?

Challenge

Let T5 be the set of all transpositions on the set {1,2,3,4,5}. Let * be the conjugacy operation on T5 defined by x * y=xyx^(-1) (here concatenation denotes the group operation). In other words, the underlying set of T5 consists of all 10 pairs (a,b) of distinct numbers from {1,2,3,4,5} and where we declare (a,b)=(b,a). The operation * is the unique operation on the underlying set that satisfies

• (a,b) * (c,d)=(c,d),
• (a,b) * (b,c)=(a,c),
• (a,b) * (a,b)=(a,b)

whenever a,b,c,d are distinct.

What is the simplest n bit input reversible circuit C along with an injective function R:T5->{0,1}^n such that C(R(x),R(y))=(R(x),R(x*y)) for all x,y in T5?

The gate cost of a reversible circuit shall be the sum of the costs of every individual logic gate in the reversible circuit.

Here is the price chart per logic gate (see this link for a description of the logic gates) along with a description of the reversible gates.

Each SWAP gate (x,y)->(y,x) will have a cost of 0.

Each NOT gate x-> NOT x shall have a cost of 1.

Each CNOT gate (x,y)->(x,x XOR y) shall have a cost of 2.

Each Fredkin gate (x,y,z)->(x,(NOT x AND y) OR (x AND z),(x AND y) OR (NOT x AND z)) shall have a cost of 4 (the Fredkin gate can also be described as the reversible logic gate where (0,x,y)->(0,x,y) and (1,x,y)->(1,y,x)).

Each Toffoli gate (x,y,z)->(x,y,(x AND y) XOR z) shall have a cost of 5.

No other gates are allowed.

Observe that each reversible gate has the same number of inputs as it has outputs (this feature is required for all reversible gates).

The complexity of your circuit will be the product of the gate cost or your circuit with the number n which you choose. The goal of this challenge will be to minimize this measure of complexity.

Format

Complexity: This is your final score. The complexity is the product of the number n with your total gate cost.

Space: State the number n of bits that your circuit C acts on.

Total gate cost: State the sum of the costs of each of the individual gates in your circuit C.

NOT gate count: State the number of NOT gates.

CNOT gate count: State the number of CNOT gates.

Toffoli gate count: How many Toffoli gates are there?

Fredkin gate count: How many Fredkin gates are there?

Legend: Give a description of the function R. For example, you may write

(1,2)->0000,(1,3)->0001,(1,4)->0010,(1,5)->0011,(2,3)->0100, (2,4)->0101,(2,5)->0110,(3,4)->0111,(3,5)->1000,(4,5)->1001.

Gate list: Here list the gates in the circuit C from first to last. Each gate shall be written in the form [Gate type abbreviation,lines where the gates come from]. For this problem, we shall start with the 0th bit. The following list specifies the abbreviations for the type of gates.

T-Toffoli gate S-Swap gate C-CNOT gate F-Fredkin gate N-Not gate.

For example, [T,1,5,3] would denote a Toffoli gate acting on the 1st bit, the 5th bit, and the 3rd bit. For example, [T,2,4,6] produces the transformation 01101010->01101000 and [C,2,1] produces 011->001,010->010 and [N,3] produces 0101->0100. For example, one could write [S,7,3],[N,2],[T,1,2,3],[F,1,2,5],[C,7,5] for the gate list.

The gates act on the bit string from left to right. For example, the gate list [C,0,1],[C,1,0] will produce the transformation 01->11.

Sample answer

Complexity: 80

Space: 5

Total gate cost: 16

NOT gate count: 3

CNOT gate count: 2

Toffoli gate count: 1

Fredkin gate count: 1

Legend: (1,2)->00001,(1,3)->00011,(1,4)->00101,(1,5)->00110,(2,3)->01000,(2,4)->01011,(2,5)->01100,(3,4)->01110,(3,5)->10001,(4,5)->10011

Gate list: [N,1],[N,0],[N,4],[S,1,2],[S,2,3],[C,0,1],[C,2,3],[T,3,2,1],[F,4,3,2,1]

Sandbox

Answer 12

Compile Brainbash to BF

code-golf

Background

BF is an esolang known for it's terseness and small character set. The language operates on a tape of unsigned 8-bit integers, and with a pointer to modify certain values. This pointer starts at the first cell. BF has the following commands available to program with:

+       increment the current cell
-       decrement the current cell
>       move the pointer to the next cell on the right
<       move the pointer to the next cell on the left
.       output the current cell as a character
,       take a character of input
[       begin a loop while the current cell is not zero
]       end that loop

Brainbash is a language similar to BF, but it has two tapes. To deal with this, Brainbash has a "tape focus"; one tape at a time is being worked on. Each tape also has its own pointer. Thus, Brainbash has a few more commands in addition to BF's:

~       swap the tape focus
*       swap tapes and copy the pointer from the previous tape to the next one
{       if the current cell is not zero, execute the code until the next `}` that matches 
}       marks the end an if statement

(There are more commands, but they are not being considered for the purposes of this challenge.)

Challenge

Given a non-empty Brainbash program P, translate that program to BF. That is, output a program Q whose I/O behavior is identical to that of P.

This is a code-golf, so the shortest in program (in bytes) that successfully does this wins.

Specific rules

• You may assume that each tape is infinite to the right starting at the origin.
• You may assume that the input is a valid program which has matching { and } and [ and ].

Example Test Cases

(to be introduced)

Answer 13

Make it rotationally-symmetric

code-golf

(sandbox note: am I using the wrong terminology?)

Background

While looking at this challenge, I notice many some of the answers has 4-fold rotational symmetry. I think it would be convenient to have a program to automatically do it.

Challenge

• Take input as a string, for which when separated by newlines, all line has equal length. (i.e., the input is rectangular)
• The output is the smallest square with 4-fold rotational symmetry, where the top-left corner is equal to the rectangle.

Sample input/output

Input:
aba
bab
aba

Output:
aba
bab
aba

Input:
 begin write('left')end.// 
/e .dne)'thgir'(etirw nigeb

Output:
 begin write('left')end.// 
/e .dne)'thgir'(etirw nigeb
/g                        e
.i                       .g
dn                       di
n                        nn
ew                       e 
)r                       )w
'i                       'r
tt                       ti
fe                       ht
e(                       ge
l'                       i(
'r                       r'
(i                       'l
eg                       (e
th                       ef
it                       tt
r'                       i'
w)                       r)
 e                       we
nn                        n
id                       nd
g.                       i.
e                        g/
begin write('right')end. e/
 //.dne)'tfel'(etirw nigeb 

Input:
abc
cde

Output:
abcca
cdedb
ce ec
bdedc
accba

Winning criteria

code-golf.

Answer 14

Mini Castle Wars king-of-the-hill game javascript

Note: This is very early draft, and I'll try to develop when I get some time to spare.

---

Inspired by a previous KOTH based on a card game (but not actually a card game).

Background

This challenge involves a simplified version of the card game Castle Wars.

Game rules

Gameplay

Just like many other card games, Castle Wars is a two-player turn-based game.

Each player starts with 30 units of castle, 5 units of fence, no shield, 2 workers, 8 bricks, 2 magicians, and 8 crystals. Each player is dealt (TBD, 5?) cards from his own deck at start.

Each resource has the following function:

• Castle: Directly related to the winning condition (see below).
• Fence: Fences can block the opponent's attack. If the attack would damage the castle by N units, the fence is damaged N units instead. If the fence is less than N units, it becomes zero and the remaining damage is dealt to the castle.
• Shield: If a castle is shielded, it can nullify any amount of damage to the castle AND the fence, exactly once. Shield can't be stacked.
• Workers: Each worker produces one brick every turn.
• Magicians: Each magician produces one crystal every turn.
• Bricks and Crystals: Every card spends some of these resources to take effect.

Each turn works as follows:

1. He gets the resources produced by his own workers and magicians.
2. The player draws a card from his own deck.
3. He plays a card. If he has enough resources, the card takes effect immediately (including the resources spent). Otherwise, it has no effect whatsoever.
4. The played card returns to the deck, and the deck is shuffled.

In order to compensate the first-player advantage, resource generation is skipped at the first turn of the game. (TBD)

Cards & deck

A deck consists of at least (TBD) cards, and may include at most (TBD) copies of the same card.

Here is the full list of cards.

• (TBD, will reflect the actual cards in the game)

Winning condition

A player wins if the opponent's castle is destroyed (0 units or below), or his own castle grows to 100 units or higher. If 100 turns are passed without a player winning, the one with higher castle is declared the winner. Same castle height after 100 turns is a draw.

Tournament

Every bot will have (TBD, even number) matches with every other bot, alternating the first turn.

Controller

TBD. This will ideally be implemented in KOTH-Webplayer.

Submission guide

A submission will look like this:

Deck

'AAAAABBBBBCCDDEXYZ'

Bot

return hand[Math.random()*hand.length|0];

The Deck is a string literal that describes the list of cards your bot will use. The Bot is a snippet that will fit into the following function's body:

function play(hand, myResources, opResources, opPlayed, storage) {
    // function body here
}

The description of parameters:

• hand is an Array of (TBD) cards in your bot's hand. Your bot's job is to choose a card to play.
• myResources and opResources are two Objects that have the information of all the resources (the bot's and the opponent's, respectively). Available keys are castle, fence, worker, brick, magician, crystal, shield. (shield is a Boolean indicating whether the player's castle is shielded or not; others are simple numbers.)
• opPlayed is the card played at the opponent's last turn.
• storage is an Object you can freely use to store information between turns. It is initially empty ({}).

---

Meta

• I originally planned to have a simplified version of the original Castle Wars, but on second thought, the rules are not that complicated and removing some resource types may break the balance of the game (as some interesting cards have to be revised). Would it be good to implement the full game instead?

Answer 15

Prettify Pixiedust

code-golf

---

So Pixiedust is a new esolang I've created. One of the primary points is that it should look like pixie dust—exactly the things that your programs should fix.

Input

The input will be a program written in Pixiedust. Since this is not a challenge to parse the language, it won't be in raw code, but a list of numbers and the strings separating them. The numbers can be taken as the number itself, or their representation in the program.

Randomizing the Literals

For each numeric literal, there are many ways to represent them:

• Randomly pad the beginning with . characters. It should be an even distribution between padding it to 32 bits and padding it to the base length.
• If the number is at the end of the line, then take an even split between including and excluding the terminating *.

Scattering

At this point, you should have the lines calculated—let's call this the half-pretty program. For each line of output:

• Start with a line of pure spaces 4 times the length of the longest half-pretty line.
• Randomly select spaces from it to replace with program characters. Every combination of spaces should have an equal chance.
• Replace those spaces with the corresponding characters, without changing the order that they appear in.
• (Optional) trim off trailing spaces.

Scoring

The winner will be the shortest answer in bytes. Additionally, there will be a 50-rep bounty for the first answer written in Pixiedust.

---

Examples will be coming once I finish the interpreter and make some submissions to other challenges in Pixiedust.

Answer 16

Iteration Hierarchy

math code-golf function

This is based on the m(n) map. m_k takes in k functions and one natural input n, and iterates the first function n times onto the next argument, and then fills in the rest of the arguments.

\$m_1=f_0\mapsto n\mapsto f_0^n(n)\$

\$m_2=f_1\mapsto f_0\mapsto n\mapsto f_1^n(f_0)(n)\$

\$m_3=f_2\mapsto f_1\mapsto f_0\mapsto n\mapsto f_2^n(f_1)(f_0)(n)\$

etc. where \$f^n(x)=f(f(f(\dots f(x)\dots)))\$ with \$n\$ calls to \$f\$ (a.k.a. function iteration).

Note particularly that \$m_2(f_1)(f_0)(2)=f_1(f_1(f_0))(2)\ne f_1(f_1(f_0(2)))\$ i.e. it iterates the first argument over the second argument and then applies the remaining arguments afterwards.

---

Examples:

Let \$s(n)=n+1\$.

m₁(s)(5)

m₁(s)(5)
= s(s(s(s(s(5)))))                                x5 iterations of s
= 10

m₁(m₁(s))(4)

m₁(m₁(s))(4)
= m₁(s)(m₁(s)(m₁(s)(m₁(s)(4))))                   x4 iterations of m₁(s)
= m₁(s)(m₁(s)(m₁(s)(s(s(s(s(4)))))))              x4 iterations of s
= m₁(s)(m₁(s)(m₁(s)(8)))
= m₁(s)(m₁(s)(s(s(s(s(s(s(s(s(8))))))))))         x8 iterations of s
= m₁(s)(m₁(s)(16))
= ...
= m₁(s)(32)
= ...
= 64

m₂(m₁)(s)(3)

m₂(m₁)(s)(3)
= m₁(m₁(m₁(s)))(3)                                x3 iterations of m₁
= m₁(m₁(s))(m₁(m₁(s))(m₁(m₁(s))(3)))              x3 iterations of m₁(m₁(s))
= m₁(m₁(s))(m₁(m₁(s))(m₁(s)(m₁(s)(m₁(s)(3)))))    x3 iterations of m₁(s)
= m₁(m₁(s))(m₁(m₁(s))(m₁(s)(m₁(s)(s(s(s(3)))))))  x3 iterations of s
= m₁(m₁(s))(m₁(m₁(s))(m₁(s)(m₁(s)(6))))
= ...
= m₁(m₁(s))(m₁(m₁(s))(24))
= m₁(m₁(s))(m₁(s)(m₁(s)(m₁(s)(m₁(s)(m₁(s)(m₁(s)(m₁(s)(m₁(s)(m₁(s)(m₁(s)(m₁(s)(m₁(s)(m₁(s)(m₁(s)(m₁(s)(m₁(s)(m₁(s)(m₁(s)(m₁(s)(m₁(s)(m₁(s)(m₁(s)(24)))))))))))))))))))))))))
= ...
= m₁(m₁(s))(402653184)
= ...
= ???

m₃(m₂)(m₁)(s)(2)

m₃(m₂)(m₁)(s)(2)
= m₂(m₂(m₁))(s)(2)                                x2 iterations of m₂
= m₂(m₁)(m₂(m₁)(s))(2)                            x2 iterations of m₂(m₁)
= m₁(m₁(m₂(m₁)(s)))(2)                            x2 iterations of m₁
= m₁(m₂(m₁)(s))(m₁(m₂(m₁)(s))(2))                 x2 iterations of m₁(m₂(m₁)(s))
= m₁(m₂(m₁)(s))(m₂(m₁)(s)(m₂(m₁)(s)(2)))          x2 iterations of m₂(m₁)(s)
= m₁(m₂(m₁)(s))(m₂(m₁)(s)(m₁(m₁(s))(2)))          x2 iterations of m₁
= m₁(m₂(m₁)(s))(m₂(m₁)(s)(m₁(s)(m₁(s)(2))))       x2 iterations of m₁(s)
= m₁(m₂(m₁)(s))(m₂(m₁)(s)(m₁(s)(s(s(2)))))        x2 iterations of s
= m₁(m₂(m₁)(s))(m₂(m₁)(s)(m₁(s)(4)))
= m₁(m₂(m₁)(s))(m₂(m₁)(s)(8))
= m₁(m₂(m₁)(s))(m₁(m₁(m₁(m₁(m₁(m₁(m₁(m₁(s))))))))(8))
= ...
= ???

Aside:

This hierarchy is closely related to the fast-growing hiearchy when using a base function of s.

In fact, the last example is already much larger than Graham's number, and \$m_n(m_{n-1})\dots(m_1)(s)(n)\approx f_{\varepsilon_0}(n)\$ in the fast-growing hierarchy.

Code Golf Challenge:

Write the shortest possible function subprogram for \$m_k\$. Code size is measured in bytes.

Here's an example program (Ruby, I can golf this down to about 140 bytes):

iterate=->f,n{->g{
    i=g
    n.times{i=f[i]}
    i}}

m=->k{
    x="->n{y=iterate[f#{k-1},n]; (0...#{k-1}).map{|l| y=eval(\"y[f\#{l}]\")}; y[n]}"
    (0...k).map{|l| x="->f#{l}{"+x+"}"}
    eval(x)}

NB: As noted above, the growth rate of \$m_n(m_{n-1})\dots(m_1)(s)(n)\$ is comparable to \$f_{\varepsilon_0}(n)\$. If this can be golfed far enough below 100 bytes, it could well place in the top 5 of the Largest Number Printable question.

Answer 17

Challenge

Max Sum String

Given an input string, return the max word based on the sum of each word's unicode characters.

Rules

• The input should be seperated by whitespace
• The value of each word is based on the sum of each character in the word's UTF-16 code
• The output should be the word

Examples

Input: "a b c d e"
Output: "e"

Input: "this is a test"
Output: "test"

Input: "test Test"
Output: "test"

Input: "hello world"
Output: "world"

Input: "💀 👻 🤡 🦇 🕷️ 🍬 🎃"
Output: "🕷️"

I doubt it's optimal at all, but here's the code I came up with to accomplish this challenge:

let str = "hello world";
Object.keys(str.split(' ').map(w => {return {[w]: [...w].map(c => c.charCodeAt(0)).reduce((a, b) => a + b, 0)}}).reduce((a, b) => { return Object.values(a)[0] > Object.values(b)[0] ? a : b}))[0];

Answer 18

Converting a number from Zeckendorf Representation to Decimal

moved to main

Answer 19

Be there, for the square

Answer 20

Ascii Table to UTF-8

When I write documentation, comments, etc. I love making ASCII tables. They usually end up looking pretty good, but I always feel that they could look even better - especially since UTF-8/Unicode includes the box drawing characters. However, these characters are very burdensome to use, requiring several key presses to insert. Your task? Write a program or a function that can automatically convert ASCII tables to the UTF-8/Unicode equivalent.

Challenge

Write a program, that given an ASCII table as an input string, outputs the table redrawn with the Unicode/UTF-8 box drawing characters. Specifically, the characters that are a part of the table should be translated as follows:

(Unicode)
- to ─ (\u2500)
| to │ (\u2502)
= to ═ (\u2550)

and + to one of:
   ┌ (\u250C), ┐ (\u2510), └ (\u2514), ┘ (\u2518),
   ├ (\u251C), ┤ (\u2524), ┬ (\u252C), ┴ (\u2534),
   ┼ (\u253C)
or, if '=' on either side:
   ╒ (\u2552), ╕ (\u2555), ╘ (\u2558), ╛ (\u255D),
   ╞ (\u255E), ╡ (\u2561), ╤ (\u2564), ╧ (\u2567),
   ╪ (\u256A)

Details

I/O:

• Default I/O is allowed
• You may take a path to a file instead of the table as a string.
• You may output to a file and take the file name as an additional argument.
  • However, you may not modify the input file. (It should be retained for ease of future editing)

Input:

• You may assume that every row of input has been padded to be the same length with .
• You may not assume that the first character after a newline is a part of the table borders (as it may be whitespace).
• Input is considered a valid table if all characters (that are a part of the table) -=| are connected to exactly two characters and + are connected to at least one character both horizontally and vertically.
• Your program may not produce any errors with valid inputs.
• If the input is not valid the behavior is undefined and you may produce any output.

Output:

• Any of the characters -=|+ that are not a part of the table must be left as-is.
• Similarly, any other characters must be left as-is.
• A single leading and/or trailing newline is allowed.

Other:

• Standard loopholes are forbidden, as per usual.
• If your preferred language has a built-in that solves this problem, you may not use it.
  • This means programs, functions, subroutines or instructions that would be valid submissions for this challenge with no additions.

Connected characters:

A character is connected to another, if:

• It is | and is directly above or below + or |;
• It is - and is directly before or after + or -;
• It is = and is directly before or after + or =;
• It is + and is directly above or below | or +, or is directly before or after -, = or +.

A character is considered a part of the table, if it is connected to any character that is a part of the table. By definition, the first + in the input is a part of the table.

Examples

Examples available here as a copy-pastable version.

 Input:                    Output:
+------------------+      ┌──────────────────┐
|   Hello+World!   |      │   Hello+World!   │
+==================+      ╞══════════════════╡
| This is+my first |  ->  │ This is+my first │
|+-+ code|golf  +-+|      │+-+ code|golf  +-+│
|+-+chall|enge! +-+|      │+-+chall|enge! +-+│
+------------------+      └──────────────────┘

     +===+===+===+             ╒═══╤═══╤═══╕
     | 1 | 2 | 3 |             │ 1 │ 2 │ 3 │
 +---+===+===+===+         ┌───╪═══╪═══╪═══╡
 | 1 | 1 | 2 | 3 |         │ 1 │ 1 │ 2 │ 3 │
 +---+---+---+---+    ->   ├───┼───┼───┼───┤
 | 2 | 2 | 4 | 6 |         │ 2 │ 2 │ 4 │ 6 │
 +---+---+---+---+         ├───┼───┼───┼───┤
 |-3 |-3 |-6 |-9 |         │-3 │-3 │-6 │-9 │
 +===+---+---+---+         ╘═══╧───┴───┴───┘

      +-----+         ->      <Undefined>

      +-----+         ->      ┌─────┐
      +-----+                 └─────┘

+-----------------+
|  Hello, World!  |
| This is invalid |   ->      <Undefined>
|      input      |
 -----------------+

       ++++                      ┌┬┬┐
       ++++           ->         ├┼┼┤
       ++++                      └┴┴┘

       +--+
       ++++           ->      <Undefined>
       +--+

Finally...

This is code-golf, so the least amount of bytes wins. Happy golfing!

code-golfascii-art

Answer 21

One line keyboard

Answer 22

Idolize Me! - JS idol simulation KotH king-of-the-hilljavascriptsimulation

Introduction

There are quite a lot of ACG titles featuring idols in Japan. Inspired by different kinds of such games, I decided to make up my idol simulation game.

What is "Idolize Me!™"?

Idolize Me!™ (tentative) is based on an idol training facility featuring a monthly tournament, in which all idols compete for fame. Every idol has the following 4 kinds of attributes (or abilities):

• Eloquence (How well you speak)
• Singing (How well you sing)
• Dance (How well you dance)
• Performance (How well you act)

Also, every idol has the corresponding improvisation level (affects on-stage performance) and specialized skills. There are training courses to upgrade these abilities and skills, and idols can also "learn" from rivals during monthly tournaments to gain abilities and improvisation.

The tournament is a Swiss-system tournament, idols gain and lose fame during 1-on-1 performance battles, and gain fame according to their overall tournament results. Each battle consists of 3 rounds, selected from the 4 types of performances with different focusing attributes:

• Stand-up comedy battle (Eloquence)
• Duet battle (Singing)
• Dance battle (Dance)
• Drama battle (Performance)

Each idol can choose to ban one type he/she does not want to participate, and can choose to specify one type he/she want to participate. Other rounds will be selected randomly, and after 3 rounds, the idol who wins more rounds wins the battle. It is possible to end up with a draw, but this is very rare.

Every one starts with the same amount of fame. After 3 years of training and competitions, the most famous idol will become the Super Idol!

Algorithmic Explanation

• Each idol starts with 2500 units of fame, 10000 units of ability to be allotted to the 4 attributes by yourself, and 20 units of improvisation and 10 units of skill per attribute.
• The main loop consists of the following components, and will be run for 36 rounds (=3 years):
  • Training (4 rounds per round): Each idol will be given 100 units of ability and 5 units of improvisation. You can allot however you wish, but beware that improvisation caps at 50 units per attribute. After allotment you can learn some skills or to strengthen your abilities at the cost of losing some improvisation. Every unit of improvisation can be converted to 5 units of ability or 0.2 units of skill. Beware that skill also caps at 50 units per attribute.
  • Tournament: After 4 rounds of training there will be the tournament. The tournament will be a Swiss-system tournament, and consist of \$\lceil log_2(n+1) \rceil\$ rounds, where \$n\$ is the number of idols. Each round will be run in the following manner:
    1. Group the idols into a group of 2 according to their running rankings.
    2. For each group, each idol chooses one attribute from the 4 attributes, and discloses its corresponding ability.
    3. Then, being told the attributes and abilities, each idol decides one attribute to ban. Giving up the chance to ban is allowed.
    4. Next, being told the choice of ban, each idols decides one round to battle. They can still choose the banned choice, but the choice will be replaced by random rounds.
    5. Fill the remaining rounds with random rounds not being banned until there are 3 rounds.
    6. In each round, each idol can choose whether to use skill of the attribute of the round. There is only one chance of using skills per idol per a 3-round battle. Then the final score of each idol will be calculated with the following formula:

$$ score=\sum_{attr}{\Biggl\lfloor ability_{attr}\times multiplier_{type,attr}\times\left[0.7+r\times \left(0.3+\frac{improvisation_{attr}}{100}\right)\right]\times\left(1+\frac{skill_{attr}}{100}\right)\Biggr\rfloor} $$

Where \$ability_{attr}\$ is your ability, \$improvisation_{attr}\$ is your improvisation, \$skill_{attr}\$ is your skill, all of the attribute \$attr\$, and \$r\$ is a random number in the range\$[0, 1)\$, with a slightly larger probability near \$1\$. The value of \$multiplier_{type,attr}\$ is in the table below:

      type   | Stand-up comedy     Duet Battle  Dance Battle  Drama Battle
attr         | Battle (Eloquence)  (Singing)    (Dance)       (Performance)
-------------+-------------------------------------------------------------
Eloquence    | 1.5                 0.8          0.5           1.2
Singing      | 0.8                 1.5          1.2           0.5
Dance        | 0.5                 1.2          1.5           0.8
Performance  | 1.2                 0.5          0.8           1.5   

• (contd)
  • (contd)
    7. The idol with higher score wins the round, and idol who wins more rounds wins the battle.
    8. Winner of the battle will be award 2 points, loser 0 points, and in the case of a draw, 1 point each.
    9. Winner gets extra 10 units of ability and 1 unit of improvisation. For each losing round, the defeated idol gets 20 units of ability and 2 unit of improvisation, and for each draw round, each idol gets 30 units of ability and 3 unit of improvisation, to be allotted at the same time (Beware again that improvisation caps at 50 units per attribute.) -- This is the core of so-called "learning from rivals".
    10. The delta fame is calculated as \$\lfloor10\times diff\times\frac{fame_{loser}}{fame_{winner}}\rfloor\$, where \$diff\$ is the difference of winning rounds in the battle. Winner gets this amount and loser loses this amount of fame.
    11. If the number of idols is odd, the idol who ranked the last will be consider a 0-battle win automatically, so fame, ability and improvisation are not affected.
    12. Sort the idols according to the following order, with the one at the top having the highest priority, all in descending order:
        1. Tournament points (TP)
        2. Number of battles won
        3. Battle difference (BD) (Number of rounds won - Number of rounds lost)
        4. Number of rounds won (BF)
        5. Score difference (PD) (Total score got - Total score lost)
        6. Total score got (PF)
        7. Drawing lots
  • After all rounds, fame will be awarded by the following formula:

$$ increase_{fame_{idol}}=\Biggl\lfloor\left[\left(\frac{n - rank + 1}{n}\right)^{1.5}\times 80+20\right]\times\frac{fame_{average}}{fame_{idol}}\Biggr\rfloor $$

Where \$n\$ is the number of idols.

Submission requirements:

Your bot must be a JS function with a name, prefably a human name (because the idol theme), distinct from other bots, that accepts an integer argument id (you must not change this argument name) and returns an object with 2 fields and 8 functions. The 2 fields are id and name (please don't change the id, line in the template). The 8 function are as follows:

1. allot(type, amount): Allotment of amount units of type.

   • Arguments:
     • type: one of "ability" or "improvisation", the type to be allotted
     • amount: an integer, the amount to be allotted
   • Return values:
     • An object with 4 numbers named E, S, D and P, denoting your decision of the allotment of the 4 attributes. The 4 numbers must sum up to amount, otherwise your decision will be voided.

2. review(ranking, battles): Your bot can review the battle results and adjust your plans.

   • Arguments:
     • ranking: an array of objects of the following entries, in ascending order of the bots' ranking, the running ranking during the tournament:
       • id: an integer, the ID of the bot
       • W: an integer, battle wins
       • D: an integer, battle draws
       • L: an integer, battle losses
       • BF: an integer, rounds won
       • BA: an integer, rounds lost
       • BD: an integer, BF - BA
       • PF: an integer, total score won by the bot
       • PA: an integer, total score won by opponent
       • PD: an integer, PF - PA
       • pts: an integer, tournament points
     • battles: an array of objects of the following entries, the details of all battles:
       • aID: an integer, the ID of idol A
       • aWin: an integer, rounds idol A won
       • aPtTotal: an integer, total score idol A got
       • bID: an integer, the ID of idol B. -1 stands for no opponent
       • bWin: an integer, rounds idol B won
       • bPtTotal: an integer, total score idol B got
       • result: an array of the following entries, the details of the sub-rounds of the battle:
         • attribute: one of "E", "S", "D" or "P", the attribute of the round
         • aTotal: an integer, the score of idol A
         • bTotal: an integer, the score of idol B
   • Return values:
     • None.

3. learn(): Your bot can learn one type of skill at the cost of the improvisation of that attribute.

   • Arguments:
     • None.
   • Return values:
     • null, or an object of the following entries, the decision:
       • attribute: one of "E", "S", "D" or "P", the skill you want to learn
       • unit: a positive number, the amount you want to learn. You cannot learn more than your improvisation of that attribute allows.

4. convert(): Your bot can strengthen one type of ability at the cost of the improvisation of that attribute.

   • Arguments:
     • None.
   • Return values:
     • null, or an object of the following entries, the decision:
       • attribute: one of "E", "S", "D" or "P", the ability you want to strengthen
       • unit: a positive number, the amount you want to strengthen. You cannot strengthen more than your improvisation of that attribute allows.

5. disclose(rival): Disclose your attribute during battle.

   • Arguments:
     • rival: an integer, rival's ID
   • Return values:
     • one of "E", "S", "D" or "P", the attribute you want to disclose

6. forbid(rival, attribute, value): Bans an attribute during battle.

   • Arguments:
     • rival: an integer, rival's ID
     • attribute: one of "E", "S", "D" or "P", the attribute rival discloses
     • value: an integer, the ability of that attribute rival discloses
   • Return values:
     • one of "E", "S", "D" or "P", the attribute you want to ban

7. choose(attribute, value, forbidden): Chooses an attribute during battle.

   • Arguments:
     • attribute: one of "E", "S", "D" or "P", the attribute rival discloses
     • value: an integer, the ability of that attribute rival discloses
     • forbidden: one of "E", "S", "D" or "P", the attribute rival bans
   • Return values:
     • one of "E", "S", "D" or "P", the round you want to choose

8. skill(attribute): Decides whether to use skill.

   • Arguments:
     • attribute: one of "E", "S", "D" or "P", the attribute of the round
   • Return values:
     • true or false, the decision whether to use skill of the attribute of the round.

Here is a template to use:

function YourIdolBot(id) {
    // Your local storage
    
    return {
        id, // Don't change this line
        name: "", // Your bot's name
        allot(type, amount) {
            // Your logic
            
            // Your return value
            return {
                E: 0,
                S: 0,
                D: 0,
                P: 0
            };
        },
        review(ranking, battles) {
            // Your logic
            
        },
        learn() {
            // Your logic
            
            // Your return value
            return {
                attribute: "",
                unit: 0
            };
        },
        convert() {
            // Your logic
            
            // Your return value
            return {
                attribute: "",
                unit: 0
            };
        },
        disclose(rival) {
            // Your logic
            
            // Your return value
            return "";
        },
        forbid(rival, attribute, value) {
            // Your logic
            
            // Your return value
            return "";
        },
        choose(attribute, value, forbidden) {
            // Your logic
            
            // Your return value
            return "";
        },
        skill(attribute) {
            // Your logic
            
            // Your return value
            return false;
        }
    }
}

Your submissions must not:

• Corrupt the simulation;
• Return values beyond requirements;
• Call IdolizeMeAPI.query() with other bot's ID (see below);
• Affect other bots' code;
• Fetch external sources;
• Define and use new global variables;
• Has expletive inside the code (Beware of idols' image)

Violations will render the bot invalid and thus be disqualified and excluded from the simulation.

API

Idolize Me! provides an API that lets your idol bot query the current stats of its own. By calling IdolizeMeAPI.query(id) with your bot's ID. YOU MUST NOT CALL IdolizeMeAPI.query() WITH OTHER BOT'S ID. THIS WILL LEAD TO DISQUALIFICATION. This method returns an object with the following entries, which is the details of your bot:

• id: an integer, your bot's id
• name: a string, your bot's name
• ability: an object with 4 numbers named E, S, D and P, your bot's ability of each attribute
• improvisation: an object with 4 numbers named E, S, D and P, your bot's improvisation of each attribute
• skill: an object with 4 numbers named E, S, D and P, your bot's skill of each attribute
• fame: a number, your bot's fame

Test Area

Here is a snippet that allows test on the bots:

function log(msg) {
  $("#log").html($("#log").html() + msg + "\n\n");
}

function cls() {
  $("#log").html("");
}

function startIdolizeMeAPI(bots, seed, loopRounds, logBattles) {
	const ALLOT_LIMIT = {
		ability: Infinity,
		improvisation: 50,
		skill: 50
	};
	const MULTIPLIER = {
		E: {E: 1.5, S: 0.8, D: 0.5, P: 1.2},
		S: {E: 0.8, S: 1.5, D: 1.2, P: 0.5},
		D: {E: 0.5, S: 1.2, D: 1.5, P: 0.8},
		P: {E: 1.2, S: 0.5, D: 0.8, P: 1.5}
	};

	function checkAllot(idol, type, amount, add) {
		var values = idol.idol.allot(type, amount);
		var total = 0;
		for (var i of "ESDP")
			total += values[i];
		if (Math.abs(total - amount) < 1e-10) {
			if (add) {
				for (var i of "ESDP") {
					idol[type][i] += values[i];
					if (idol[type][i] > ALLOT_LIMIT[type])
						idol[type][i] = ALLOT_LIMIT[type];
				}
			}
			else {
				for (var i of "ESDP") {
					if (values[i] > ALLOT_LIMIT[type])
						values[i] = ALLOT_LIMIT[type];
				}
				return values;
			}
		}
		else if (!add)
			return {E: 0, S: 0, D: 0, P: 0};
	}
	var Random = (function(randomSeed) {
		function next() {
			return Math.random();
		}
		function nextInt(n) {
			return next() * n |0;
		}
		return {
			next,
			nextInt,
			pick: a => a[nextInt(a.length)],
			shuffle: function(a) {
				for (var l = a.length; l > 1;) {
					var o = nextInt(l--);
					[a[l], a[o]] = [a[o], a[l]];
				}
				return a;
			}
		};
	})(seed);

	var idols = bots.map(x => ({
		id: x.id,
		name: x.name,
		idol: x,
		ability: checkAllot({idol: x}, "ability", 10000, false),
		improvisation: {E: 20, S: 20, D: 20, P: 20},
		skill: {E: 10, S: 10, D: 10, P: 10},
		fame: 2500
	}));
	var numIdols = bots.length;

	function calcTotal(attr, idol, skill) {
		var total = 0;
		for (var i of "ESDP")
			total += idol.ability[i] * MULTIPLIER[attr][i] * (70 + Math.pow(Random.next(), 0.8) * (30 + idol.improvisation[i]) + skill * idol.skill[i]) / 100 |0;
		return total;
	}

	function battle(a, b) {
		var aDis = a.idol.disclose(b.id), bDis = b.idol.disclose(a.id), aSkill = false, bSkill = false, aWin = 0, bWin = 0, aAllot = 0, bAllot = 0;
		var aForbid = a.idol.forbid(b.id, bDis, b.ability[bDis]), bForbid = b.idol.forbid(a.id, aDis, a.ability[aDis]);
		
		var rounds = [Random.pick("ESDP"), a.idol.choose(bDis, b.ability[bDis], bForbid), b.idol.choose(aDis, a.ability[aDis], aForbid)].filter(x => x != aForbid && x != bForbid);
		while (rounds.length < 3) {
			var round = Random.pick("ESDP");
			if (round != aForbid && round != bForbid)
				rounds.push(round);
		}
		Random.shuffle(rounds);
		var result = rounds.map(function (x) {
			var aUseSkill = a.idol.skill(x), bUseSkill = b.idol.skill(x);
			var aTotal = calcTotal(x, a, !aSkill && aUseSkill), bTotal = calcTotal(x, b, !bSkill && bUseSkill);
			aSkill |= aUseSkill;
			bSkill |= bUseSkill;
			if (aTotal > bTotal) {
				aWin++;
				bAllot += 20 * aTotal / bTotal |0;
			}
			else if (bTotal > aTotal) {
				bWin++;
				aAllot += 20 * bTotal / aTotal |0;
			}
			else {
				aAllot += 30;
				bAllot += 30;
			}
			return {
				attribute: x, 
				aTotal, 
				bTotal
			};
		});
		if (aWin > bWin) {
			aAllot += 10;
			var deltaFame = 10 * Math.abs(aWin - bWin) * b.fame / a.fame |0;
			a.fame += deltaFame;
			b.fame -= deltaFame;
		}
		else if (bWin > aWin) {
			bAllot += 10;
			var deltaFame = 10 * Math.abs(aWin - bWin) * a.fame / b.fame |0;
			a.fame -= deltaFame;
			b.fame += deltaFame;
		}

		if (aAllot > 0) {
			checkAllot(b, "ability", aAllot, true);
			if (aAllot >= 10)
				checkAllot(b, "improvisation", aAllot / 10 |0, true);
		}
		if (bAllot > 0) {
			checkAllot(b, "ability", bAllot, true);
			if (bAllot >= 10)
				checkAllot(b, "improvisation", bAllot / 10 |0, true);
		}
		var aPtTotal = 0, bPtTotal = 0;
		for (var i of result) {
			aPtTotal += i.aTotal;
			bPtTotal += i.bTotal;
		}

		return {
			aID: a.id,
			bID: b.id,
			result, 
			aWin, 
			bWin,
			aPtTotal, 
			bPtTotal
		};
	}

	var totalBattleResult = {};
	idols.map(x => totalBattleResult[x.id] = {
		W: 0,
		D: 0,
		L: 0,
		BF: 0,
		BA: 0,
		BD: 0,
		PF: 0,
		PA: 0,
		PD: 0,
		pts: 0,
		rankings: []
	});

	function swissBattle() {
		var idolRanking = idols.map(x => ({
			idol: x,
			W: 0,
			D: 0,
			L: 0,
			BF: 0,
			BA: 0,
			BD: 0,
			PF: 0,
			PA: 0,
			PD: 0,
			pts: 0
		}));
		function sortRanking() {
			for (var idol of idolRanking)
				idol.lots = Random.next();
			idolRanking.sort((a, b) => b.pts - a.pts || b.W - a.W || b.BD - a.BD || b.BF - a.BF || b.PD - a.PD || b.PF - a.PF || b.lots - a.lots);
		}
		sortRanking();

		for (var i = numIdols; i > 0; i >>= 1) {
			var battles = [];
			for (var j = 0; j < numIdols - 1; j += 2) {
				var a = idolRanking[j], b = idolRanking[j + 1]
				var result = battle(a.idol, b.idol);
				battles.push(result);
				if (result.aWin > result.bWin) {
					a.W++;
					b.L++;
				}
				else if (result.bWin > result.aWin) {
					a.L++;
					b.W++;
				}
				else {
					a.D++;
					b.D++;
				}
				a.pts = a.W * 2 + a.D;
				b.pts = b.W * 2 + b.D;
				a.BF += result.aWin;
				a.BA += result.bWin;
				b.BF += result.bWin;
				b.BA += result.aWin;
				a.PF += result.aPtTotal;
				a.PA += result.bPtTotal;
				b.PF += result.bPtTotal;
				b.PA += result.aPtTotal;
				a.BD = a.BF - a.BA;
				b.BD = b.BF - b.BA;
				a.PD = a.PF - a.PA;
				b.PD = b.PF - b.PA;
			}
			if (numIdols % 2 == 1) {
				idolRanking[numIdols - 1].W++;
				idolRanking[numIdols - 1].pts += 2;
				battles.push({
					aID: idolRanking[numIdols - 1].idol.id, 
					bID: -1, 
					result: [], 
					aWin: 0, 
					bWin: 0
				});
			}
			sortRanking();
			var publicRanking = idolRanking.map(function(x) {
				var l = {};
				for (var i in x) {
					if (i == "idol")
						l.id = x.idol.id;
					else if (i != "lots")
						l[i] = x[i];
				}
				return l;
			});
			for (var idol of idols)
				idol.idol.review(publicRanking, battles);
			if (logBattles) {
        log("Battle Results:\n" + JSON.stringify(battles, null, 2));
        log("Ranking:\n" + JSON.stringify(publicRanking, null, 2));
      }
		}
		var averageFame = idols.reduce((a, b) => a + b.fame, 0) / numIdols;
		for (var i = 0; i < numIdols; i++)
			idolRanking[i].idol.fame += (Math.pow((numIdols - i) / numIdols, 1.5) * 80 + 20) * averageFame / idolRanking[i].idol.fame |0; 

		var r = 0;
		for (var p of idolRanking) {
			for (var q in p) {
				if (q != "idol" && q != "lots")
					totalBattleResult[p.idol.id][q] += p[q];
			}
			totalBattleResult[p.idol.id].rankings.push(++r);
		}
	}

	function showResult(round) {
		var temp = [...idols].sort((a, b) => b.fame - a.fame);
		var a =        " ID                 | Name                        | Fame  | Win  | Lose | Draw | BF   | BA   | BD   | Pts For   | Pts Aga.  | Pts Diff. | TP   | Tournament Rankings                                                                                         \n"
		      +        "--------------------+-----------------------------+-------+------+------+------+------+------+------+-----------+-----------+-----------+------+-" + "-".repeat(Math.max(20, loopRounds * 3));
		for (var i of temp) {
			a += `\n ${("" + i.id).padStart(18)} | ${i.name.padEnd(27) } | ` + ("" + i.fame).padStart(5);
			for (var j of ["W", "L", "D", "BF", "BA", "BD", "PF", "PA", "PD", "pts"])
				a += " | " + ("" + totalBattleResult[i.id][j]).padStart(j[0] == "P" ? 9 : 4);
			a += " | " + totalBattleResult[i.id].rankings.map(x => ("" + x).padStart(2)).join` `;
		}
		log("Round " + round + " results:\n" + a);
    return a;
	}

	function loop() {
		for (var i = 0; i < loopRounds; i++) {
			for (var j = 0; j < 4; j++) {
				for (var k of idols) {
					checkAllot(k, "ability", 100, true);
					checkAllot(k, "improvisation", 5, true);
					var convertPlan = k.idol.convert();
					if (convertPlan) {
						var {attribute, unit} = convertPlan;
						var converted = Math.min(unit, k.improvisation[attribute] * 5);
						k.improvisation[attribute] -= converted / 5;
						k.ability[attribute] += converted;
					}
					var learnPlan = k.idol.learn();
					if (learnPlan) {
						var {attribute, unit} = learnPlan;
						var learnt = Math.min(unit, k.improvisation[attribute] / 5);
						k.improvisation[attribute] -= learnt * 5;
						k.skill[attribute] += learnt;
						if (k.skill[attribute] > ALLOT_LIMIT.skill)
							k.skill[attribute] = ALLOT_LIMIT.skill;
					}
				}
			}
			swissBattle();
			showResult(i + 1);
		}
	}

	return {
		loop,
		query(id) {
			var idol = idols.filter(x => x.id == id)[0];
			if (idol) {
				var publicIdol = {};
				for (var i in idol) {
					if (i != "idol")
						publicIdol[i] = idol[i];
				}
				return publicIdol;
			}
			else 
				return null;
		},
		showResult
	};
}

var players = 0;
function addPlayer() {
  var id = Math.random() * Math.pow(2, 53);
  $("#players").append(`
    <div class="bot" id="bot-${id}">
      <textarea cols="100" rows="10"></textarea> ${++players > 2 ? `<input type="button" value="Delete this bot" onclick="deletePlayer(${id})">` : ""}
    </div>
  `);
}

function deletePlayer(id) {
  $("#bot-" + id).remove();
  players--;
}
/*
$("#run").on("click", function(e) {
  e.preventDefault();
  e.stopPropagation();
  e.target.checkValidity();
  console.log("test");
});*/
var IdolizeMeAPI;
$(document).on("submit", "form", function(e) {
  e.preventDefault();
  cls();
  var bots = [], submissions = {};
  $(".bot").each(function(s) {
    var code = $(this).find("textarea").val();
    var botFunctionName = /function (\w+) *\(id\) *{/.exec(code);
    if (botFunctionName) {
      botFunctionName = botFunctionName[1];
      code = code.replace(/function (\w+) *\(id\) *{/, `submissions["$1"] = function(id) {`);
      eval(code);
      bots.push(new submissions[botFunctionName](+$(this).attr("id").slice(4)));
    }
  });
  IdolizeMeAPI = startIdolizeMeAPI(bots, "whatever it is we don't use seeds at all", +$("#rounds").val(), $("#logbattle").prop("checked"));
  IdolizeMeAPI.loop();
  return false;
});

addPlayer();
addPlayer();

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<form>
  Rounds: <input id="rounds" pattern="\d+" value="6" required/><br>
  Log battle results: <input type="checkbox" id="logbattle"><br>
  Player Bots:
  <div id="players">
  </div>
  <input type="button" value="Add a bot" onclick="addPlayer()"><br>
  <input id="run" type="submit" value="Run simulation">
</form>
<pre id="log">
</pre>

You may want to open the snippet in a new page.

Demo Bots

2 simple demo bots will be in the same contest with submitted bots, of exactly the same implementation, but with different names: One called Yamada Ransu (山田 乱數) and one called Sato Midare (佐藤 乱).

function TheTwoSimpleDemoBotsYouAreCompetingWith(id) {
    return {
        id: id,
        name: "???",
        allot(type, amount) {        
            return {
                E: amount/4,
                S: amount/4,
                D: amount/4,
                P: amount/4
            };
        },
        review(ranking, battles) {},
        learn() {
            return {
                attribute: "ESDP"[Math.random() * 4 |0],
                unit: Math.random() * 5 |0
            };
        },
        convert() {
            return null;
        },
        disclose(rival) {
            return "ESDP"[Math.random() * 4 |0];
        },
        forbid(rival, attribute, value) {
            return "ESDP"[Math.random() * 4 |0];
        },
        choose(attribute, value, forbidden) {
            return "ESDP"[Math.random() * 4 |0];
        },
        skill(attribute) {
            return Math.random() < 0.5;
        }
    }
}

Winning Criteria

Submission is open for 2 weeks from the posting day, until 15:00 GMT on the end day, or until there are more than 20 submissions, whichever is later. You are welcomed to submit multiple entries during the period. After the the submission period ends, the 36 rounds will be simulated within 3 days. After the 36 rounds, the bot with the highest fame wins, and the corresponding submission will be accepted as "best answer". The simulation result will be posted.

Answer 23

Not All Sums Are Equal

code-golfmathnumerical-analysissum

Introduction

When computing the sum of a list of floating point values, the order in which we add up the summands matters. A good way to reduce errors is beginning with the summand with the least modulus and working your way up to the numbers with a greater modulus. As an illustrative example, let us assume our computer uses floating point numbers that comprise 2 (decimal) digits \$m_1,m_2\$ for the mantissa (and a sufficiently large number of digits for the exponent \$e\$.) These represent a number \$0.m_1m_2 \cdot 10^e\$. Let us consider the list

[0.1, 0.009, 0.009]

The exact result would obviously be \$0.118\$, and the best approximation in our computer therefore \$0.12\$. But if we actually tell the computer to sum those numbers, it will truncate all intermediate results, so it will get:

 (0.1 + 0.009) + 0.009 = 0.1 + 0.009 = 0.1

If we use the recipe from above and sort the list by the modulus first, we get

(0.009 + 0.009) + 0.1 = 0.018 + 0.1 = 0.11

which is already closer to the exact result. So we see that any permutation in the order of the summation might produce a different sum. In order to estimate the possible error we're interested in the difference between the greatest and the least sum we can get by just using a permutations of the original list. This is the task of this challenge.

Examples

The following examples assume that you use IEEE-754 double numbers in your implementation. You can of course use other implementations, but the results might be different:

[0.0140534017661288 0.50942429920538 1 1.96300019759529 71.1571487560538]
1.42108547152020e-14
[-0.447570988743782 -0.30397649549556 0 0.765285061877593 3.30425088014391]
8.88178419700125e-16

Answer 24

Posted: Is this number secretly Fibonacci?

Answer 25

floating-point logic-gates atomic-code-golf

Toy floating point coprocessor: ceil

Summary: implement the ceiling function for 16-bit IEEE 754 floating point numbers in logic gates, using as few gates as you can.

16-bit IEEE 754 floating point

For a more detailed description, see Wikipedia:Half-precision floating-point format.

The 16 bits are divided into three chunks: sign (1 bit), exponent (5 bits), mantissa (10 bits).

• The sign is 0 for positive numbers and 1 for negative numbers.
• The exponent is biased: interpret as an unsigned 5-bit number and subtract 15 to get the true exponent. Special cases are described below.
• The mantissa is an unsigned 10-bit number with an implicit leading 11th bit which depends on the exponent.

If the exponent is 00000 (corresponding to -15), the number is subnormal. The implicit leading bit of the mantissa is 0, but there's a bonus factor of two, so the interpreted value is \$(-1)^{\textrm{sign}}\; 2^{-14}\; 0.\textrm{mantissa}\$, or (expanding the \$0.\textrm{mantissa}\$ binary notation) \$(-1)^{\textrm{sign}}\; 2^{-24}\; \textrm{mantissa}\$.

If the exponent is 11111 (corresponding to 16), the number is either infinite (if the mantissa is 0000000000) or a NaN.

For all other exponents, the implicit leading bit of the mantissa is 1, so the interpreted value is \$(-1)^{\textrm{sign}}\; 2^{\textrm{exponent}-15}\; 1.\textrm{mantissa}\$, expanded to \$(-1)^{\textrm{sign}}\; 2^{\textrm{exponent}-25}\; (2^{10} + \textrm{mantissa})\$

Ceiling function

The ceiling function maps real numbers to integers, rounding up. So if the input value is an integer, the output value is unchanged; if the input value is not an integer, the output value is the smallest integer greater than the input value.

Examples:

$$\begin{array}{c|c} x & \textrm{ceil}(x) \\ \hline -1 & -1 \\ -0.5 & 0 \\ 0 & 0 \\ 0.00001 & 1 \\ 1 & 1 \\ 1.8 & 2 \\ \end{array}$$

Corner cases

Given an infinity, the output must be the same infinity.

Given a NaN, the output must be a NaN, but it can be any NaN.

IEEE 754 floating point systems have signed zeroes. Given a zero, the output must be the same zero.

Gates and scoring

You must implement a logic gate with 16 inputs and 16 outputs. You may use any two-input logic gates and you may mix different types of logic gates. We idealise the gates: don't worry about things like fan-out limitations or propagation delays. The score is the number of gates, and the fewer the better. If you choose to explain your design by giving code which uses bitwise operation on integers, be sure to document clearly how many bits are being processed by each operation.

Test cases

TODO, but will cover both infinities, both signed zeroes, positive and negative subnormals, positive and negative integer values, positive and negative non-integer values, and a NaN.

Answer 26

Minimize your standard deviation

code-challenge math

---

The standard deviation of a collection of numbers is calculated in the following manner:

1. Find the arithmetic mean of the collection.
2. Find the difference of each item from the mean.
3. Square each difference and sum them.
4. Divide by the number of items in the collection minus 1.
5. Take the square root.

Or, expressed mathematically:

$$ s = \sqrt{ \frac{ \sum^N_{i=1} (x_i - \bar x)^2 }{N - 1} }, $$

where \$N\$ is the number of items, \$x_i\$ is the \$i\$th item, and \$\bar x\$ is the arithmetic mean.

Challenge

Your challenge is to write a program or function in your language of choice that, given an array of bytes, calculates the standard deviation of the array. The catch: the standard deviation of the bytes in your code will be added to your score.

Rules

• Input may be in any reasonable format (e.g. numbers separated by newlines or commas, an actual array or buffer, etc.)
• You may assume that the items in the input are all integers \$0 \le n < 256\$.
• You may assume that there are at least two integers in the input.
• The output or return value must be the standard deviation of the array as calculated above, accurate to at least 2 decimal places (i.e. \$ \pm 0.005 \$)

Test cases

(test cases to come)

Scoring

The score of your code is its length in bytes, plus the standard deviation of its bytes (i.e. \$N + s\$). The code with the lowest score in each language wins.

(If you somehow find a language with a 1-byte built-in that fulfills the challenge, your score will just be 1. In the impossible case of a 0-byte built-in, your score will be \$0 + \frac{0}{-1} = 0\$.)

Sandbox questions

• Is this too similar to the vanilla standard deviation challenge?
• For non-golfing languages that primarily use ASCII, the standard deviation will likely be much lower than the byte count, leading to golfing the code being significantly more important than reducing \$s\$. How could this best be combated? \$\sqrt N + s\$? \$N + s^2\$? (where \$N\$ is the length of the code) Obviously I wouldn't want to just use \$s\$, as you could just append one byte (e.g. ; in many languages) over and over to lower it arbitrarily.

Answer 27

Calculate your Icy Score

Answer 28

Classify arity of verbs inside trains in J code-golf parsing j

Related: Clearly parenthesize APL trains

Background

J is an APL-family language. While it inherits the basic train syntax from APL (take a look at the linked challenge above), J is more versatile with the introduction of [:, & and @ among many others. But the problem is, the more features a tacit expression has, the harder it is to read and understand what it does. Even worse, most of the built-in verbs have both monadic and dyadic usage, and some of them have two completely different meanings! So let's build a helper to classify the arity of verbs.

Notations

• # is a monadic verb.
• + is a dyadic verb.
• [ is a special symbol called "cap" which can appear at specific positions inside a train.
• @ and & are conjunctions, which take two verbs on both sides and form a single verb.
• x and y are left and right arguments to a given train, respectively. If x is missing, the train is called monadically (with one argument y); otherwise, dyadically (with both arguments).

Basics

• In a train of verbs, the last 3 verbs are recursively grouped.
• Conjunctions bind from left to right.

Rules

Monadic
(# + #) y   =>  (# y) + (# y)
(+ #) y     =>  y + (# y)
([ # #) y   =>  # (# y)
(+ # + #) y =>  (+ (# + #)) y
(# + # + # + #) y => (# + (# + (# + #))) y
(# + [ # # + #) y => (# + ([ # (# + #))) y

Dyadic
x (+ + +) y   =>  (x + y) + (x + y)
x (+ #) y     =>  x + (# y)
x ([ # +) y   =>  # (x + y)
x (+ # + #) y =>  x (+ (# + #)) y    <= the 3-group is run monadically
x (+ + + + + + +) y => x (+ + (+ + (+ + +))) y
x (+ + [ # + + +) y => x (+ + ([ # (+ + +))) y

Conjunction &
(#&#) y   => # (# y)
x (+&#) y => (# x) + (# y)

Conjunction @
(#@#) y   => # (# y)
x (#@+) y => # (x + y)

How to determine arity of each verb

   (?  (? ?&?@?    ?) ?) y
=> (# d(? ?&?@?    ?) #) y    monadic 3-train: # + #
=> (#  (+ d?&?@?   +) #) y    dyadic 3-train:  + + +
=> (#  (+ d(?&?)@? +) #) y    conjunction binds from left; arity is determined from right
=> (#  (+ m(?&?)@+ +) #) y    dyadic `@`:  #@+
=> (#  (+  (#&#)@+ +) #) y    monadic `&`: #&#

Challenge

Given an expression that represents the structure of a J train, determine the arity of every verb in the expression.

Input & output

TBD

Test cases

TBD

Scoring & winning criterion

Standard code-golf rules apply. The shortest valid program or function in each language wins.

Answer 29

How fast can I Flood-It?

code-golf grid sequence

There's a one-player game called Flood-It, in which the player must flood the whole board with one color within a certain number of moves.

• The board is a two-dimensional square grid of size n.
• At the start, each square in the grid is one of k colors.
• A move consists of selecting a color, and doing a 4-connected flood fill with that color starting in the top left corner.

For example, selecting Red on this size-3 board with 4 colors:

GGE
RGB
RDE

causes the board to change to this—now the two already-red squares are connected to the top left:

RRE
RRB
RDE

After the further moves DBE, all squares are colored Emerald, and the game has been won in an optimal 4 moves.

Challenge

Given two integers n and k, output the number of moves required to win the game of Flood-It with those parameters, in the worst case over all possible arrangements of colors.

Answer 30

mAkE a StRiNg EpIc code-golf string

Now that the meme is mostly dead, we can have this challenge. It's pretty simple: take a string (either as stdin or a parameter to a function), and change the case to alternate capital and lowercase letters, starting with lowercase. Examples:

"Hello, World!" -> "hElLo, WoRlD!"
"PPCG" -> "pPcG"
"Ok now this is epic" -> "oK nOw ThIs Is EpIc"
"" -> ""

Rules:

• Can take input as a parameter to a function or as stdin

• Punctuation marks are left alone

• Must not take any input other than the input string

• It's code-golf, so the shortest code in bytes wins!

Sandbox questions:

• The obvious one: is it a duplicate? I don't think so, but I don't know for sure.

• Is it too trivial for some languages?

Thanks everyone!