Sum in 2540 Sums code-golf pristine-programming code-shuffleboard

^{This is my attempt to pair code-shuffleboard with code-golf.}

You need to write a program that sums all codepoints of the input string.

Rules

• The input will always be in printable ASCII.

• The sum of the codepoints of your source must be exactly 2540.

  • You are allowed to use your language's own code page to calculate your program's codepoints.

• Null bytes (which don't contribute to your codepoint sum) are banned.

• The program must not work with any consecutive substring removed.
• This is code-golf. Your score is the length of your source code, the shorter being better.

Will this simplified befunge-93 program terminate? code-golf decision-problem

The challenge today is to solve the halting problem for simplified befunge-93.

Simplified befunge-93 has exactly four instructions - > v < ^ @. The program is restricted to a 80x24 grid. Each of the commands modifies the instruction pointer (so that, for instance > makes the instruction pointer start executing commands to the right), except of the @ instruction, which terminates the program.

When the instruction pointer reaches the end, it wraps around (imagine the snake game).

You may read input in form of a string or a two-dimensional array using any reasonable device. The output may be either a truthy value if the program terminates, or a falsy value if the program doesn't terminate.

Example data

Input: >v ^< Output: Doesn't terminate. ---------------------------------------- Input: > v @ ^ < Output: Doesn't terminate. ---------------------------------------- Input: v@ [23 newlines] >v Output: Terminates. ---------------------------------------- Input: v @ [23 newlines] >v Output: Doesn't terminate. ---------------------------------------- Input: Output: Doesn't terminate. 

Posted.

Complete a sequence using its distances code-golfsequenceinteger

Given \$A = (a_1,\dots,a_k)\ k\ge2 \$ a nonrepetitive sequence of positive integers.
Starting from \$i=2\$, while \$a_i\in A:\$

• If \$d=|a_i-a_{i-1}|\$ is not already in \$A\$, append \$d\$ to \$A\$
• Increase \$i\$

Output the completed sequence.

Example

In: 16 20 13 3 16 20 13 3 4 --^ 16 20 13 3 4 7 --^ 16 20 13 3 4 7 10 --^ 16 20 13 3 4 7 10 1 --^ 16 20 13 3 4 7 10 1 --^ 16 20 13 3 4 7 10 1 --^ 16 20 13 3 4 7 10 1 9 --^ 16 20 13 3 4 7 10 1 9 8 --^ Out: 16 20 13 3 4 7 10 1 9 8 

This is code-golf

_

Bot Duels KOTH king-of-the-hilljavascript

Obligatory blurb adding story fluff. Or, maybe a self-referential paragraph about meta-self-referential blurbs? Or: <announcer voice> Will your bot survive... The Arena? </announcer voice>. Yes, I think a good non-self-referential (such as this) short paragraph full of short sentences without run-ons or many, many, many, many commas will suffice.

Overview

This is a King-of-the-Hill challenge. Bot with the most wins wins. You may submit multiple bots as long as they differ in strategy. Bots will play against every other bot. The bot who is currently playing against every other bot goes first, and goes second when their opponent is playing against every other bot. Bots will face off in an arena with x boundaries of 10 and -10 and y boundaries of 10 and -10. Bots will either start at (-5, 0) or (5, 0). Your goal is to defeat the other bot by reducing it's HP to 0 or less. Bots start with 20+armor modifier HP and do not regenerate health. Your bot defeats the other bots using weapons, which have damage, range, and cooldown. Armor has speed.

Submissions

Submissions should be a JS function that takes the following parameters:

• curr_x - the current x coordinate of your bot
• curr_y - the current y coordinate of your bot
• enemy_x - the current x coordinate of your opponent's bot
• enemy_y - the current y coordinate of your opponent's bot
• enemy_armor - the armor that your enemy is wearing
• storage - a storage object you can use to store data between function calls

The function should return an array with 3 items (in the following order):

• desired x - the x coordinate you want to move to
• desired y - the y coord you want to move to
• use weapon? - if true, and desired x and desired y are Infinity, then you use your weapon

Submissions should be structured as

Weapon: your weapon here
Armor: your armor here

function definition block 

Explanation underneath, if any.

Armor

(currently designing new weapons and armor) The types of armor available are:

• Light - increases HP by 3, has a speed of 3
• Medium - increases HP by 5, has a speed of 2
• Heavy - increases HP by 7, has a speed of 1

Weapons

The types of weapons are:

• Laser - High-range, high-damage, low ROF. 5 points of damage, 5 rounds to cool down, and a range of 6 units
• Rifle - General-purpose weapon. 5 damage, range of 4, 3 rounds to cool down.
• Sword - High-ROF, high-damage spiky thing. 5 points of damage, really low range of 1, and a rather quick 2 rounds to cool down.

Turns

On your turn, you can either move or use weapon (or do nothing, if that's what you really want to do).

• If you move, you can move a distance (computed using the Euclidean Distance formula) less-than or equal-to (<=) your armor's speed.
• If you choose to use weapon, and if the enemy is in range of your weapon, then you deal damage equal to your weapon's damage and the weapon goes into cooldown. A weapon in cooldown can't be used. Weapons can be used after a number of turns equal to their cooldown property has passed after being used.
• To do nothing, simply return your current x and y coordinates, like so: return [curr_x, curr_y, false].

Rules

• If you try to use a weapon during cooldown, nothing happens and your turn ends
• If you try to use a weapon and your opponent is out of range, nothing happens and your turn ends.
• If you try to move more than your armor's speed, nothing happens and your turn ends
• If you try to move out-of-bounds, same thing
• If you move into another bot's space, then the bot with the lowest HP loses and the bot with the highest HP wins, making this a viable strategy.
• All standard loopholes (accessing controller, duplicate bots, suicide bots, etc.) are, of course, disallowed.

Examples

TowerDefense Weapon: Laser
Armor: Heavy

function(curr_x, curr_y, enemy_x, enemy_y, enemy_armor, storage) { let actions = [Infinity, Infinity, true]; return actions; } 

Just sits and shoots, lol. A perfectly viable strategy (and a rather strong one, too, while weapons are still being reworked). Takes the highest-hp armor available because it doesn't need to move at all.

DumbBot

Weapon: Rifle
Armor: Medium

function(curr_x, curr_y, enemy_x, enemy_y, enemy_armor, storage) { let actions = [curr_x, curr_y, false]; // if storage is empty if (!storage.data) { // then write our starting loc storage.data = curr_x.toString() + " " + curr_y.toString(); } // if we're starting at x = -5 if (storage.data.includes("-5")) { if (curr_x < 3) { // move right actions[0] += 2; actions[1] = curr_y; } // otherwise we must be close enough else {storage.data = "shoot";} } 

Assumes enemy doesn't move (such as TowerDefense). Moves to the enemy's starting location, then shoots. As such, takes the Medium armor and the Rifle. Kind of a generic all-purpose bot, like the weapons and armor it uses.

Controller

The controller can be found here. Run all current submissions here.

Best of luck, and, may the odds be ever in your favor (even though this is a 1v1 and not a FFA)

Sandbox

• Are the rules explained thoroughly? Is anything unclear?
• Is the game (armor, weapons, punishment for breaking rules, etc.) balanced well? Are there any strategies that dominate?
• Would this KOTH be fun?
• Would you participate in the competition?
• Any obvious bugs in the (horribly messy) controller code?
• Create a simple submission similar to something that you would actually submit and test it against the example bots. Is the code still working?

Posted.

Is this Chessboard Reachable?

The goal of this challenge is to determine, given the state of a chessboard, whether or not that chessboard can actually be reached in the course of standard play. Of course, doing this in general is a rather hard problem, so we'll be simplifying the problem to a set of a few rules which should approximate the "reachability" constraint.

Your input will be a chessboard, specifying what pieces are at what positions on the 8x8 board. At each position, there can be either nothing or a piece. If there is a piece, it is either a pawn, bishop, knight, rook, queen, or king, and it is either white or black. Input can be taken in any reasonable form. Your output should be truthy or falsy, indicating whether all of the below rules are satisfied.

For the below rules, I'll be using standard chess notation to refer to the squares on the board. That is, I'll be referring to squares on the board by their rank (1-8) and their file (a-h), as such

 8........ 7........ 6........ 5........ 4........ 3........ 2........ 1........ abcdefgh 

where the white player starts on ranks 1-2 and the black player starts on ranks 7-8. Obviously, you don't have to use the same notation, and if it's easier for you to take the board input flipped or rotated, that's fine too as long as you specify it in your answer.

For one of the rules, you have to distinguish between white and black squares on the board. The board is layered with a checkerboard pattern, so white squares are always immediately surrounded by black on all four sides, and vice versa. In typical chess, the a1 square is black, but that doesn't really matter for the below criteria.

The Rules

In order for a board to be considered reachable, it must satisfy all of the following rules. This is decision-problem, so you don't have to tell me which rule an unreachable board violated; all I expect of your output is a "yes" or a "no".

1. White and black each have exactly one king on the board: no more, no less.

2. Pawns cannot appear on rank 1 or rank 8.

3. Each player has a maximum of 16 pieces on the board total. These pieces must be a subset of the following: 2 bishops, 2 rooks, 2 knights, 1 queen, 1 king, and 8 wildcards. The "wildcard" pieces can be any piece they please (since we assume pawns could have been promoted).

4. For either player, if that player has at least two bishops, and those two bishops cannot have been promoted from pawns (i.e. they must be the "bishops" in rule 3, not the "wildcards"), then that player must have at least one bishop on a white square and at least one bishop on a black square.

5. All of a player's pawns must be able to reach the square they're occupying. More formally, for each player, there must be an assignment (an injective function) from the set of that player's surviving pawns to the files (a-h) they started on, such that each pawn can reach its current position from its starting position with only forward and forward-diagonal movements.

Pawn Movements

Rule 5 may require some elaboration. Suppose a white pawn is on d5. Then it could have come from the following places (indicated by X)

 8........ 7........ 6........ 5...♙.... 4..XXX... 3.XXXXX.. 2XXXXXXX. 1........ abcdefgh 

So it could have started on a2, b2, c2, d2, e2, f2, or g2, but not h2. There must be an assignment of pawns to starting positions such that no two pawns started at the same position and every pawn can reach its current position from where it began. A black pawn follows the same rules but started on rank 7 and moves down rather than up. So a black pawn at the same position could have come from b7, c7, d7, e7, or f7, as follows.

 8........ 7.XXXXX.. 6..XXX... 5...♟.... 4........ 3........ 2........ 1........ abcdefgh 

Notes

• Only the rules above apply. Other complexities of a standard game of chess (in particular, castling or en passant) are not part of this problem and should not be considered.
• This is code-golf, so the shortest solution wins.
• Input can be taken in whatever form is most convenient. Output follows the usual decision-problem rules, so any two distinct outputs for truthy/falsy are acceptable.
• This is an oversimplification of the reachability problem in chess. As such, an answer which provably enumerates every chessboard and tests for membership is not correct.

Examples

Reachable chessboards (true):

 8♜♞♝♛♚♝♞♜ 7♟♟♟♟♟♟♟♟ 6........ 5........ 4........ 3........ 2♙♙♙♙♙♙♙♙ 1♖♘♗♕♔♗♘♖ abcdefgh 8........ 7........ 6........ 5........ 4........ 3........ 2..♚..... 1.....♔.. abcdefgh 8........ 7.....♚.. 6.♛...... 5...♟.... 4........ 3.....♕.. 2........ 1...♔.... abcdefgh 8.....♚.. 7♟♟♟♟♟♟♟♟ 6........ 5........ 4........ 3........ 2♙♙♙♙♙♙♙♙ 1....♔... abcdefgh 8.....♚... 7♟♟♟♟♟♟♟♟ 6........ 5........ 4........ 3........ 2♙♙♙♙♙♙♙♙ 1....♔... abcdefgh 8........ 7.♚...... 6...♕♕♕♕. 5..♕....♕ 4..♕..♔.♕ 3.......♕ 2........ 1........ abcdefgh 8........ 7...♚.♟.♙ 6.♙.♙..♙. 5.....♘.. 4.♕..♕♘♗♖ 3.....♘♗♖ 2..♕....♖ 1......♔. abcdefgh 8♜..♛♚♜♜♜ 7♟♟♟♟♟♟.. 6........ 5........ 4........ 3........ 2♙♙♙♙♙♙♙♙ 1♖♘♗♕♔♗♘♖ abcdefgh 8♜♞♝♛♚♝♞♜ 7♟♟♟♟♟♟♟♟ 6........ 5........ 4........ 3........ 2♙♙♙♙♙♙♙. 1♖♗♘♕♔♗♘♖ abcdefgh 8♛♛♛♛♛♛.♛ 7........ 6......♚. 5.♝.♝.... 4.....♟.. 3........ 2..♖♖♖.♔. 1........ abcdefgh 8.....♚.. 7........ 6........ 5........ 4........ 3.♙♙..... 2..♙♙♙♙♙♙ 1.....♔.. abcdefgh 8.....♚.. 7........ 6........ 5........ 4........ 3.....♙.. 2...♙♙♙.♙ 1.....♔.. abcdefgh 8.....♚.. 7........ 6.♟♟♟♟... 5.♟♟..... 4........ 3........ 2........ 1.....♔.. abcdefgh 

Unreachable chessboards (false):

(Rule 1: Not enough kings)

 8........ 7........ 6........ 5........ 4........ 3........ 2........ 1........ abcdefgh 

(Rule 1: Too many kings)

 8♚♚♚♚♚♚♚♚ 7♚♚♚♚♚♚♚♚ 6♚♚♚♚♚♚♚♚ 5♚♚♚♚♚♚♚♚ 4♚♚♚♚♚♚♚♚ 3........ 2........ 1...♔.... abcdefgh 

(Rule 2: Bad white pawn placement)

 8.....♚.. 7♟♟♟♟♟♟♟♟ 6........ 5........ 4........ 3........ 2.♙♙♙♙♙♙♙ 1♙...♔... abcdefgh 

(Rule 2: Bad black pawn placement)

 8.♟...♚.. 7♟.♟♟♟♟♟♟ 6........ 5........ 4........ 3........ 2♙♙♙♙♙♙♙♙ 1....♔... abcdefgh 

(Rule 3: Too many white queens)

 8........ 7.♚...... 6...♕♕♕♕. 5..♕....♕ 4..♕..♔.♕ 3..♕....♕ 2........ 1........ abcdefgh 

(Rule 3: Too many black pieces)

 8♜♞♝♛♚♝♞♜ 7♟♟♟♟♟♟♟♟ 6......♟. 5........ 4........ 3........ 2♙♙♙♙♙♙♙♙ 1♖♘♗♕♔♗♘♖ abcdefgh 

(Rule 3: Too many white pieces)

 8........ 7...♚.♙.♙ 6.♙.♙..♙. 5.....♘.. 4.♕..♕♘♗♖ 3.....♘♗♖ 2..♕....♖ 1......♔. abcdefgh 

(Rule 3: Too many black rooks)

 8♜..♛♚♜♜♜ 7♟♟♟♟♟♟♟. 6........ 5........ 4........ 3........ 2♙♙♙♙♙♙♙♙ 1♖♘♗♕♔♗♘♖ abcdefgh 

(Rule 4: White bishops are the same color)

 8♜♞♝♛♚♝♞♜ 7♟♟♟♟♟♟♟♟ 6........ 5........ 4........ 3........ 2♙♙♙♙♙♙♙♙ 1♖♗♘♕♔♗♘♖ abcdefgh 

(Rule 4: Black bishops are the same color)

 8♛♛♛♛♛♛♛♛ 7........ 6......♚. 5.♝.♝.... 4.....♟.. 3........ 2..♖♖♖.♔. 1........ abcdefgh 

(Rule 5: White pawn placement is impossible)

 8.....♚.. 7........ 6........ 5........ 4........ 3..♙..... 2.♙♙♙♙♙♙♙ 1.....♔.. abcdefgh 

(Rule 5: White pawn placement is impossible)

 8.....♚.. 7........ 6........ 5........ 4........ 3.....♙.♙ 2...♙♙♙.♙ 1.....♔.. abcdefgh 

(Rule 5: Black pawn placement is impossible)

 8.....♚.. 7.♟♟♟♟... 6........ 5.♟♟..... 4.♟♟..... 3........ 2........ 1.....♔.. abcdefgh 

Example Implementation (Python 3)

# Takes input from stdin in the form shown above (a grid of Unicode # chess characters and dots). Prints True if reachable. Prints False # and the first rule number which is violated if unreachable. import sys from collections import defaultdict, namedtuple Piece = namedtuple('Piece', ['color', 'type']) # Read in the data from stdin. data = [] for line in sys.stdin: chars = list(filter(lambda x: x in ".♟♙♝♗♞♘♜♖♛♕♚♔", line)) if chars: data.append(chars) if len(data) == 8: break assert len(data) == 8 for line in data: assert len(line) == 8 # Parse it into a more convenient format. translation = { ".": None, "♟": Piece('black', 'pawn'), "♙": Piece('white', 'pawn'), "♝": Piece('black', 'bishop'), "♗": Piece('white', 'bishop'), "♞": Piece('black', 'knight'), "♘": Piece('white', 'knight'), "♜": Piece('black', 'rook'), "♖": Piece('white', 'rook'), "♛": Piece('black', 'queen'), "♕": Piece('white', 'queen'), "♚": Piece('black', 'king'), "♔": Piece('white', 'king'), } for rank in data: for i in range(8): rank[i] = translation[rank[i]] # Count the number of each piece that each player has, slotting # necessary pawn promotions into their own category. allowed = { 'bishop': 2, 'rook': 2, 'knight': 2, 'king': 999, 'queen': 1, 'pawn': 0 } pieces = defaultdict(lambda: 0) for rank in data: for piece in rank: if piece is None: continue if pieces[piece] >= allowed[piece.type]: # Already have too many; it's a promoted pawn pieces[Piece(piece.color, 'pawn')] += 1 else: # Count it normally pieces[piece] += 1 # Rule 1: Each color should have exactly one king. if pieces[Piece('white', 'king')] != 1 or pieces[Piece('black', 'king')] != 1: print(False, 1) exit(0) # Rule 2: Pawns cannot appear on rank 1 or rank 8. for piece in data[0] + data[7]: if piece is not None and piece.type == 'pawn': print(False, 2) exit(0) # Rule 3: Since we already put any "overflow" pieces at the pawn key, # we just need to make sure we have at most eight pawns. for color in ['white', 'black']: if pieces[Piece(color, 'pawn')] > 8: print(False, 3) exit(0) # Rule 4: If we have both bishops and our pawns are all accounted for, # then we have to have a bishop in each color. for color in ['white', 'black']: if pieces[Piece(color, 'bishop')] >= 2 and pieces[Piece(color, 'pawn')] >= 8: squares = { 'white': False, 'black': False } for y, rank in enumerate(data): for x, piece in enumerate(rank): square_color = 'white' if (x + y) % 2 == 0 else 'black' if piece == Piece(color, 'bishop'): squares[square_color] = True if not (squares['white'] and squares['black']): print(False, 4) exit(0) # Rule 5: All pawns must be able to get to where they are. I solve # this here by brute force (simply trying every possible permutation), # which is exponentially inefficient, but it'll do for this example. def recursive_assign(taken, choices, i): if i >= len(choices): return True current = choices[i] for x in current: if x not in taken: if recursive_assign(taken + [x], choices, i + 1): return True return False for color in ['white', 'black']: starting_file = 6 if color == 'white' else 1 choices = [] for y, rank in enumerate(data): for x, piece in enumerate(rank): if piece == Piece(color, 'pawn'): possibilities = range(8) possibilities = filter(lambda i: abs(i - x) <= abs(y - starting_file), possibilities) choices.append(list(possibilities)) if not recursive_assign([], choices, 0): print(False, 5) exit(0) print(True) 

Proposed Tags

• code-golf decision-problem chess

Sandbox Concerns

• I worry Rules 4 and 5 are still not clear enough. I tried to write them in a way that was as clear as possible while still being mathematically unambiguous.

Road Sort Order

In Britain, road identifiers use a scheme of a letter, followed by a 1-4 digit number.

From Most-Important to Least-Important, the letters are:

M
A
B
C
D
U

The numbers also represent further assumptions around the importance of the road, such that a 1-digit number is more important than a 4-digit number.

Thus, the M898 is less important than the M8, but more important than the A8.

interesting but not relevant for the challenge - Roads are also sorted into nine Zones, of equal importance. The first number in each road identifier gives the Zone that the road starts in (e.g. A8 starts in Zone 8 - although there are exceptions where one Motorway spurs off of another, e.g. M48 is so named because it is a spur of the M4 even though it is officially in Zone 5).

The challenge

Given a pair of road identifiers, identify and output which is the most important road. Where there is no difference in importance by the above rules (e.g "B4063" and "B1234") then either output is acceptable.

Usual I/O rules apply, this is code-golf so lowest bytes wins. There will be two inputs, and no invalid inputs (i.e. they will follow the rules, although they may not be actual real-life roads).

If you say so in your answer, you may instead output the least significant road (i.e. as long as I know which it is, you can do either).

You may take the input as a string, array of strings, or array of strings and integers as follows:

"M123M223"
["M123","M223"]
["M",123,"M",223]

#SANDBOX# If there are input formats that you think should/n't be allowed, let me know.

Examples

• A11,M2 -> M2(Motorways come before A roads)
• M823,M89 -> M89 (two-digit roads are more important than 3-digit roads, even though 89 alphabetically comes after 823)
• A1262,A150 -> A150
• U6340,D6340 -> D6340
• M1,M2 -> Either
• B100,C99 -> B100

Posted

Shift Tac Toe code-golfgridtic-tac-toe

Shift Tac Toe is a game that combines Tic Tac Toe and Connect 4 together. In this game, you start with a 3 by 3 board, and each row is connected to a slider that you can move left and right. At the start, the sliders all start to the very right(this means that you can't move the slider to the right on the first turn). Each slider can hold a total of 5 pieces. Each turn, the player can drop an O or a X in one of the 3 columns of the Tic Tac Toe grid depending on which turn it is, or the player can move one of the sliders one spot to the left or to the right. All pieces fall to the bottom most space that is unoccupied. The pieces can also fall from one slider to another outside the 3 by 3 grid. If a piece is outside the 3 by 3 grid and doesn't fall into the bottom slider, then the piece is taken out. If it does reach the bottom slider, it will stay in play. A notable example of this is shown in the following grid:

 --- --- --- --- --- | | | | - O - --- --- --- --- --- --- - | | | | - --- --- --- --- --- --- | | | | - - --- --- --- --- --- In the grid above, the dashes(-) indicate the part of the sliders that are outside of the 3 by 3 grid and the vertical bars(|) indicate the 3 by 3 grid. As you can see, this is the starting board except that the middle slider is one spot over to the left, and that there is an O at the very top right. What happens in this scenario? There is nothing immediately underneath it, so does it go out of play? No. This is because it still falls into the bottom slider, which means that it is still in play. The final grid is this: --- --- --- --- --- | | | | - - --- --- --- --- --- --- - | | | | - --- --- --- --- --- --- | | | | - O - --- --- --- --- --- 

Pieces can also stack outside of the 3 by 3 grid. Players will alternate between O and X, with the O player going first.

Example game:

Start with 3 by 3 grid with sliders all the way to the right: --- --- --- --- --- | | | | - - --- --- --- --- --- | | | | - - --- --- --- --- --- | | | | - - --- --- --- --- --- The O player places an O in the middle column of the 3 by 3 grid and it falls to the bottom: --- --- --- --- --- | | | | - - --- --- --- --- --- | | | | - - --- --- --- --- --- | | O | | - - --- --- --- --- --- The X player then places an X in the middle column: --- --- --- --- --- | | | | - - --- --- --- --- --- | | X | | - - --- --- --- --- --- | | O | | - - --- --- --- --- --- The O player then pushes the middle row slider one space to the left. Notice that after the slider moves, there is nothing under the X anymore, so it falls down. Also note that the slider has moved one space to the right as indicated below: --- --- --- --- --- | | | | - - --- --- --- --- --- --- - | | | | - --- --- --- --- --- --- | X | O | | - - --- --- --- --- --- The X player places a X in the rightmost column: --- --- --- --- --- | | | | - - --- --- --- --- --- --- - | | | | - --- --- --- --- --- --- | X | O | X | - - --- --- --- --- --- The O player then moves the bottom slider one spot to the left. Notice that all the pieces shift one place to the left, and the leftmost X is now out of the playing field: --- --- --- --- --- | | | | - - --- --- --- --- --- --- - | | | | - --- --- --- --- --- - X | O | X | | - --- --- --- --- --- The X player places a X in the leftmost column: --- --- --- --- --- | | | | - - --- --- --- --- --- --- - | X | | | - --- --- --- --- --- - X | O | X | | - --- --- --- --- --- The O player places an O in the leftmost column: --- --- --- --- --- | O | | | - - --- --- --- --- --- --- - | X | | | - --- --- --- --- --- - X | O | X | | - --- --- --- --- --- The X player shifts the top slider one place to the left. Notice that the O falls one place down because there is nothing beneath it: --- --- --- --- --- - | | | | - --- --- --- --- --- - O | X | | | - --- --- --- --- --- - X | O | X | | - --- --- --- --- --- The O player is not very good at this game, so he shifts the middle slider one place to the right. This shifts all the pieces in the middle row one place to the right: --- --- --- --- --- - | | | | - --- --- --- --- --- --- | O | X | | - - --- --- --- --- --- --- - X | O | X | | - --- --- --- --- --- The X player wins the game by placing a X in the middle column: --- --- --- --- --- - | | X | | - --- --- --- --- --- --- | O | X | | - - --- --- --- --- --- --- - X | O | X | | - --- --- --- --- --- 

Your job is to take in a string or array of any length that only consists of 9 unique characters(you choose the characters). Three of the characters will choose which column you place the X or O(depending on whose turn it is), three of them will choose which slider to move right, and the last three will choose which slider to move left. You can assume that the input only has these 9 characters. The output should be a 3 by 3 matrix or some kind of list/string that clearly shows the final position of the grid upon following the instructions of the input. You can assume that all inputs are valid. Each character takes up a turn. Also, if any move results in a winning move(forms 3 in a row in the 3 by 3 grid like regular Tic-Tac-Toe), then ignore the rest of the input. Note that the pieces that form the winning 3 in a row all have to be in the 3 by 3 grid. The two example grids below are NOT winning positions:

Grid #1: --- --- --- --- --- | | | | - - --- --- --- --- --- | | | | - - --- --- --- --- --- | | | O | O - O - --- --- --- --- --- This is not a winning move because two of the O's are outside the playing field, despite the fact that it forms a 3 in a row. Using the character assignment stated below, this grid pattern can be achieved with 99372467643. Grid #2: --- --- --- --- --- | | | | - O - --- --- --- --- --- | | | | O - X - --- --- --- --- --- | | | O | X - X - --- --- --- --- --- This is not a winning position because two of the O's are outside the playing field. Using the character assignment below, this grid pattern can be achieved with 939318836537734654 

In the examples below, 1, 2, and 3 mean drop in the leftmost, middle, and rightmost column respectively. 4, 5, and 6 mean to move the top, middle, and bottom slider to the right respectively, and 7, 8, and 9 mean to move the top, middle, and bottom slider to the left respectively.

Examples

Input will be in the form of a string Output will be a list of lists, with each sub-list representing a row(I'm Python programmer so this list format might not be compatible with all languages). The first, second, and third sub-list correspond to the top, middle, and bottom row of the 3 by 3 grid respectively. The output will have 'O' for the O pieces, 'X' for the X pieces, and an empty string for empty spaces. Input: 123332 Output: [['','','O'], ['','X','X'], ['O','X','O']] Input: 33387741347 Output: [['','',''], ['','','O'], ['X','O','X']] Input: 2283911752 Output: [['','X',''], ['O','X',''], ['O','X','']] Input: 228374739 Output: [['','',''], ['','',''], ['X','X','X']] Input: 8873334917349 Output: [['','',''], ['','','O'], ['X','X','O']] Input: 799333466 Output: [['','',''], ['','',''], ['','','']] Input: 99372467643 Output: [['','',''], ['','',''], ['','','O']] Input: 939318836537734654 Output: [['','',''], ['','',''], ['','','O']] 

This is code-golf, so shortest code wins!

My concerns about this challenge:

Are the rules of this game explained enough? Do you understand this game?

Is this a good challenge overall?

Are the examples correct(if you understand the rules)?

Should I put more examples(or if you understand the rules, could you supply me with some)?

What other tags can this challenge fit into?

Generalized Game Theory KOTH king-of-the-hill

Game Theory is a field of mathematics that is concerned with strategic interactions among 'rational decision-makers'. The main focus of game theory is the payoff-matrix.

A payoff matrix represents an interaction between two parties, and shows how many points a party can get if they choose different strategies. Here is an example of a payoff matrix:

 Player 1 A | B Player 2 +------+------- A | 3, 3 | 5, 1 +------+------- B | 1, 5 | 2, 2 

In this example, if player 1 chooses A and player 2 also chooses A, they would both get 3 points. If player 1 chooses B but player 2 chooses A, player would get 5 points but player 2 would only get 1.

The above payoff matrix is an example of the prisoners dilemma

The challenge

Programs will face off in a round-robin tournament. Each round will consist of a randomly generated payoff matrix, with both programs choosing either strategy A or strategy B. Programs will earn points accordingly. The winner will be the program with the most points, with ties broken by source code length.

Questions for meta:

• best practices for creating KOTH challenges?
  • language considerations? I'm most comfortable with javascript but am also capable of writing in python
  • is it better to limit a KOTH to one language? it's easier to manage but limits who can submit
  • or allow multiple languages? It allows more people to compete but is more difficult to judge
• Any comments about the overall problem?
  • Has this been done before?

Implement the Polygamma function

The Turing Text Tape

Posted here: TTT: Turing Text Tape

Peel away the layers - Cops

Peel away the layers - Robbers

We're all unique in our own way

The Great Code Golf Heist

Alternatively, the most literal cops'n'robbers you'll ever see

king-of-the-hillcops-and-robberspython

Backstory

Sandbox Note: This part will be specific to each thread, so I've provided each version

Robbers

For the last few years, you and your team of robbers have been planning to rob the International Code Golf Museum (ICGM) of some of it's most prized possessions (rumour has it, they have a rare transcript of Dennis being outgolfed!). Tonight is the night that your plans will be put into action... tonight you will walk away with glorious riches and legendary artifiacts of code golf history.

That is, if you can actually manage to get in, loot the rooms and get back out without getting caught.

Cops

Tonight has been a quiet night at the Internation Code Golf Museum (ICGM)...too quiet for one's liking.

Of course, that's probably due to the fact that a bunch of robbers are rumoured to strike tonight and steal the most priceless artifacts from the ICGM's collections (we can't have them finding out the fact that Arnauld is a machine learning algorithm designed to answer challenges with Javascript, can we. [that's a joke we love you Arnauld!])

It's your job to stop the robbers and make sure that not a single thing leaves the museum.

The Museum

Sandbox Note: This part is common to both cops and robbers

Here is a map of the museum:

You may be wondering "hang on, what are the dimensions of that map?". Well the answer is simple: you don't need to know.

Movement around the ICGM is analogous to a Henry Stickmin game: in each room, you can either move to an adjacent room, or perform an action in that room.

Robbers start at the Getaway Car and can enter through either Hallway A or Hallway B. They then move through Hallway A.A then Hallway A.B or move through Hallway B.A and then Hallway B.B. Either way, they end up at the exhibition room. From the exhibition room, robbers can move to any of the treasure rooms which is where all the valuables are stored. After that, they make their way back to the getaway car to, well, escape and get away.

Cops are randomly allocated a position at the start of the heist, and can move wherever they need to.

Sandbox Note: There's going to be a system where each room takes a certain number of "strides" to get from one end to another. This way, robbers with stolen items are "slowed down" a little and the cops have a bit of a chance to catch up

Stealing Treasures

Sandbox Note: Robber specific

Once you reach a treasure room, you have the oppourtunity to get your hands on some of the finest works the ICGM has to offer. There will be a selection of items to choose from, each with different values. Sandbox Note: I might add a part where there is a limit on how much robbers can carry

However, items with more value impact how fast you can move through. Sandbox Note: Something relating to the stride system here.

But being the sneaky robbers you are, you have a few tricks up your sleeve(s). When moving through the ICGM, you can:

• Activate a trap that will slow down the cops (avaliable only once Sandbox Note: Subject to change)
• [Other things coming soon]

Once you get back to the getaway van, everything you have stolen is considered "safe" and counts towards your team's score. But once you're in the van, that's it... you can't go back for more.

Your team wins if you manage to steal items with a combined worth of insert value here

Protecting the ICGM

Sandbox Note: Cop specific

In order to protect the artifacts of the ICGM from being stolen, you have a few abilities you can use against the robbers. You can:

• Apprehend a robber if they are in your proximity
• [Other things coming soon]

For your team to win, the total value of items stolen must not exceed insert value here

The Catch

Sandbox Note: Common to both threads

The heist program will only be simulated once. That means that if your submission errors, you're out of the game for good. I mean, you don't see criminals replace the things they stole just to rerun the heist over and over to see how good they are ;P.

The heist will occur on insert date here. You can edit your submissions all you like until the time of running.

The Controller

Coming soon.

Feedback

• Seeing as how this is a first draft, there are bound to be flaws with things like the movement mechanics and cop/robber interactions. I'm more looking for first impressions and overall flaws in the challenge.

Secret ">" Stacking Challenge: cheating code-golf tetris

Sequel to Secret ">" Stacking Challenge: grading. You can skip the whole Background section if you already read the first one.

Background

Tetris Grand Master 3 has a hidden grading system based on the shape of the stack at the end of the game, which is called Secret ">" Stacking Challenge. It consists of entirely filling the lowest rows except for the zigzag pattern which starts at the left bottom cell and spans the entire width:

# .######### #.######## ##.####### ###.###### ####.##### #####.#### ######.### #######.## ########.# #########. ########.# #######.## ######.### #####.#### ####.##### ###.###### ##.####### #.######## .######### 

The board is graded by how many lines follow this exact pattern from the bottom line. Note that the topmost hole in the pattern must be blocked by an extra piece of block. If you consider the #s and .s as the mandatory pattern (blanks can be anything), you can get the score of 19 only if the exact pattern above is matched from the bottom line. Analogously, if the board matches this pattern

 # ###.###### ##.####### #.######## .######### 

but not

 # ####.##### ###.###### ##.####### #.######## .######### 

then the score is 4.

For this challenge, consider a board of arbitrary size (other than 20 cells high and 10 cells wide). We can grade the board for the same pattern: for example, if the board has width 4, this is the pattern for score 3:

 # ##.# #.## .### 

and this is the pattern for score 10:

 # ###. ##.# #.## .### #.## ##.# ###. ##.# #.## .### 

Challenge

Given the board width and the desired score for Secret ">" Stacking Challenge, pick a sequence of tetrominoes and generate the sequence of moves that will achieve the score. The Tetris moves can be represented in any ways that clearly specify where each tetromino is placed in which orientation, optionally along with the board state after each placement.

For the Tetris movement rules, we use simple permissive rule as in this challenge: you can place a tetromino anywhere (even in closed rooms), as long as it doesn't float in the air or overlap with existing pieces. Therefore, if you plan to use coordinates, you need to specify both x and y coordinates (the y coordinate should be counted from the bottom, as the board can grow upwards without bound -- or count from the top by also outputting the field height).

You can assume the width is at least 5 and the score is nonzero. You should theoretically support arbitrarily high score. The generated sequence doesn't need to be minimal.

Standard code-golf rules apply. The shortest code in bytes wins.

Output example

For board with 6 and score 2, one possible way is as follows: (As are the tetromino placed at each turn, # are existing pieces on the board, and . are empty cells)

...... ...... ...... ...... ...... A..... #..... #..... .AA... .##AA. AA.... ##AA.. ####AA #.AA.. #.##AA .A.... .#AA.. .###AA .##### .##### 

The above is a valid output format (you can choose any distinct chars/values in place of .A#). The following is also valid (although it is less obvious, it is indeed an unambiguous description of tetromino placements):

...... ...... ...... ...... ...... A..... ...... ...... .AA... ...AA. AA.... ..AA.. ....AA ..AA.. ....AA .A.... ..AA.. ....AA ...... ...... 

And this: (tetromino code, rotation, x and y coordinates from bottom left, 0 indexed)

S 1 0 0 O 0 2 0 O 0 4 0 Z 0 1 1 Z 0 3 1 

And anything in between (e.g. showing tetrominos as a canonicalized matrix instead of a code). If in doubt, ask in comments.

Calculate the inverse of a matrix

Can I print my picture on {A,B,C}{0-10} paper?

The task is to find the smallest paper size on which it is possible to print a picture of the dimensions given in milimetres. The image will be printed without margins.

Input:

Two numbers (bigger than zero) and a letter a, b, or c, for example:

290 200 A 

Output:

Paper size, for example:

A4

Another examples:

218,297,a A3 1,1,c C10 9999,9999,c ??? (error) 74,52,A A8 31,44,B B10 26,1100,A A0 

• Upper- and lowercase variants of letters "A", "B" and "C" are allowed on input and on output.
• The image can be printed vertically or horizontally.
• The values can be passed as a parameter or entered by the user.
• Width and height of picture will be always > 0, and letters will be always 'a', 'b', or 'c'. You don't need to validate them.
• You need to handle paper sizes A0 - A10, B0 - B10 and C0 - C10. If the image is too large, you can throw an exception, print an error or whatever you want, as long as it is clearly different from valid result and the application will not hung up.

Paper sizes, please ignore inch values (source: Wikipedia) :

This is code-golf - fewest bytes wins.

Brainfuck arbitrary precision multiplication

fastest-code code-challenge brainfuck

Goal

The goal is to multiply two numbers in the shortest amount of cycle.

The Input

The input is two numbers written decimally separated by a space. The number is NOT restricted by the size of the integer inside of the cells. The program must accept arbitrary sized integer

The Output

The output is a single integer written decimally.

Brainfuck variants used

Since the flavors of the Brainfuck is important in this challenge, you are required to use this flavor

Memory

The memory is an array of cells, unbounded to the left and the right, with 8-bit integer as the contents.

Input/Output

The input and the output uses ASCII symbol mapping. EOF is interpreted as \0 char.

Looping

The [ means that "check the current cell. If it's zero, jump to the instruction after the matching ]" The ] means that "jump to the matching [." no cycle is taken in this instruction.

Cycle

Every instruction takes a single cycle every time it's executed except for ]. ] is a free instruction.

Reference implementation

For the reference implementation, use copy.sh with this option:

1. Cell size (Bits): 8
2. Dynamic (infinite) Memory: yes
3. End of input: char: \0
4. Count instructions

Scoring

The winner is the program that is: (later number is for tiebreaker)

1. The program with lowest computational complexity (counted by using cycle metric as explained above, and in x where x is the length of the largest input in base 10) is the winner.
2. The program with lowest space complexity (counted by finding the rightmost cell reached by program)
3. The program that takes the least cycle to execute 1234567890*987654321
4. The program that takes the least memory to execute 1234567890*987654321
5. The shortest code

Computational complexity is determined in terms of the number of digits each arguments have.

Posted.

Jelly's Untruth

Generalised Taxicab Numbers

posted

Is my triangle on the lattice? decision-problem code-golf geometry

Posted on the main site.

Is it a Lobster Number?

Posted

BF memory layout optimizer (posted).

See the notes in the revision history.

[please review other sandbox posts]

Note:

• as you can probably tell, this is a simpler variation; however the poster of the other sandbox post has not been visiting the site for a while.
• because of the current situation, I recently (after the 2 upvotes is made) changed the winning criteria. Is there any problem with the description?
• What info should be included in the header?...

Efficient table-lookup computation

Posted: Efficient table-lookup computation

Generalise perfect numbers