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

View float numbers in graphical binary

IEEE 754 is a well known format for representing floating point numbers.

Your task is to give an input to the user where he/she enters a signed float number and represents clearly the number in a color separated by functional area binary 32 bit single representation, like:

• You do not have to append the captions like they are in the figure.

• You must follow the order Sign, Exponent, Fraction

• You may choose whatever colors you want, as they are distinguishable from each other and from the binary text numbers.

• The input (I suggest a text box) does not have to forbid invalid values, but if does not, the graphical binary view needs to indicate the invalidity. You can leave it empty or replace with some text like "ERROR" or "INVALID".

• Every little change on the input needs to make the binary view to be immediately updated. Changing and have to confirm with an "OK" like button is not acceptable.

No winner, unless I see some very creative answer. I would like to see a golfed and an ungolfed version of the code.

code-golf floating-point binary graphical-output number conversion

Answer 2

Optimise Retina transliterations

For the question Translate Morse code based on tone duration I stupidly created the following transliteration:

T`T\EMNAI\OGKDWRUSJ2V\HBZ89#@`NIGDRS8ZCBP\LF\H12356789_`\w@#

The first thing wrong with it is that it 2, 8 and 9 transliterate to themselves, so they are superfluous. This saves 6 bytes:

T`T\EMNAI\OGKDWRUSJV\HBZ#@`NIGDRS8ZCBP\LF\H13567_`\w@#

The next thing to notice is that we have some runs of consecutive letters, but because they're not ordered we can't reduce them. Let's sort them:

T`ABD\EG\HIJKMN\ORSTUVWZ#@`R6BIZ5S1CGD8\L\HNF3P7`\w@#

We can now save another 3 bytes by using the run G-K, a byte by using the run M-O, and 3 bytes by using the run R-W:

T`ABD\EG-KM-OR-WZ#@`R6BIZ5S1CGD8\L\HNF3P7`\w@#

Total 13 bytes saved. Note that there are other optimisation opportunities but I think they might be too difficult be worth adding to the question; for instance, inserting a C (at a cost of 2 bytes) allows the creation of the run A-E for a 3-byte saving, which is still overall a byte saved; inserting all of the letters to achieve run A-Z would then be simplified to L.

Is the Retina command string too inflexible an input format? I suppose input could be in the form of an unordered mapping from printable ASCII to printable ASCII, but output would need to be the actual Retina syntax, including appropriate quoting, because the length of the result is important.

(Quoting: The characters -dEOHhLlwpoR`\ need to be quoted except that the letters don't need to be quoted as part of a range.)

Should this be a code-golf question or metagolf?

Answer 3

A Knight's Walk

On a chessboard, a knight has two options for movement: it can move one square horizontally and two squares vertically, or two squares horizontally and one square vertically. In short, it can follow the path drawn by an upper-case "L". These can be oriented in any way, and as such, a knight has 8 potential moves from any given position.

There have been a number of challenges posted at one time or another regarding knights and their movement because they're so mathematically interesting (and the problems are easy to state) but we're going to go for a basic one that I haven't seen.

The Challenge

Given two 2d coordinates (x1, y1), (x2, y2) return the minimum number of moves required to travel from (x1, y1) to (x2, y2).

There are no other pieces on the board, and you may assume that the coordinate values given are valid (a set of two integers) though they may not be unique. You may also assume that each individual coordinate value will be between 0 and 255, and that the board is large enough that you needn't consider edges.

Input Format

As long as the coordinates are inputted in the order x1 y1 x2 y2 you can accept them as four separate values, two tuples, two lists, etc...

Examples

(0, 0) (1, 2) => 1
(0, 0) (1, 1) => 2
(125, 125) (126, 127) => 1
(-100, -100) (0, 100) => 100

Answer 4

Clean duplicate website from my history

coge-golf

Introduction

I am looking for help to monitor my history. I parsed everything, but I am not yet happy with the final result. Could you help me? I want to remove following same website.

My history looks like this:

| url                                               | id |
|---------------------------------------------------|----|
| https://codegolf.stackexchange.com/q/147318/15214 | 4  |
| https://codegolf.stackexchange.com/q/148927/15214 | 4  |
| https://en.wikipedia.org/wiki/Code_golf           | 3  |
| http://lichess.org                                | 2  |
| https://en.wikipedia.org/wiki/Code_poetry         | 1  |

But I want it to be:

| url                                               | id |
|---------------------------------------------------|----|
| https://codegolf.stackexchange.com/q/148927/15214 | 4  |
| https://en.wikipedia.org/wiki/Code_golf           | 3  |
| http://lichess.org                                | 2  |
| https://en.wikipedia.org/wiki/Code_poetry         | 1  |

• If I browse a site, then another one, then the first one. I keep all of them.
• If I browse a site, then another part of the same site. I keep only the first one.
• The list is ordered from young to old. (we keep the older)

This challenge is inspired by my day work, but it is not related in any ways with anything in it.

Challenge

• Input is a list of identifier.
• Output is a list of two elements (identifier's index, identifier).
• No Empty input
• No standard loophole
• This is code-golf, so shortest answer in bytes wins.

Examples Input and Output

2 links on website 1

Input:

[ 1, 1 ]

Output:

[
    [1,1]
]

1 link on website 2, then 3 links on website 1

Input:

[ 1, 1, 1, 2]

Output:

[
    [2,1],
    [3,2]
]

1 link on website 1, then 1 link on website 2, then 2 link on website 1

Input:

[ 1, 1, 2, 1]

Output

[
    [1,1],
    [2,2],
    [3,1]
]

---

Question

• Should I allow outputs as list of object, list of tuple or dictionary/map?
• Should I ask for url parsing where identifier is the hostname?

Answer 5

Implement a basic two-dimensional esolang code-golf

There are hundreds of two-dimensional stack-based esoteric programming languages out there, and lots of them follow a very similar syntax:

v redirect instruction pointer down
> redirect instruction pointer right
^ redirect instruction pointer up
< redirect instruction pointer left
/ redirect instruction pointer: up -> right, right -> up, left -> down, down -> left
\ redirect instruction pointer: up -> left, left -> up, right -> down, down -> right
0 push 0 to the stack. 1 pushes 1, ... 9 pushes 9.
A push 10 to the stack. B pushes 11, ... F pushes 15.
: duplicate the top stack value
~ swap top two stack values (all languages implement this as a different character)
i read input as a ASCII character and push to stack
o print the top of stack as an ASCII character
n read input as integer and push to stack
u print the top of stack as an integer
+ increment the top of stack
- decrement the top of stack
! jump over the next command
; stop execution

Almost all two-dimensional esolangs contain more commands, but for the sake of simplicity, the one we're writing will contain only the above.

---

Specification

The stack should be able to hold at least 30,000 values. You may pick any integer size (e.g. 32-bit, 64-bit, unbounded, etc) for stack values.

The instruction pointer should start moving right from the top left corner of the source code, and should wrap upon exiting the playing field, meaning that this code will be an infinite loop:

<^
v>

First, < will be reached, pointing the IP off to the left.
The IP will wrap around to the right, continuing left, and hit the ^, directing it up.
Then it will wrap, hit the > and travel right, wrap, hit the v and travel down, wrap, hit the <, and start over.

Answer 6

DNA Quine

Problem Description

Design a quine that outputs its own source code, but encoded into amino acids.
Read your source code in as binary. Each pair of bits now maps to a nucleotide like so:

00 -> A
01 -> C
10 -> G
11 -> T

For example, the ASCII character N has a binary representation of 01001110, so it would produce the nucleotide sequence CATG. A set of three nucleotides produces an amino acid. You can find the charts online, and I can't access imgur, so... yeah.

Anyways, your program must output its own source code as the three letter amino acid names. For example, if your code were 013201323300 in base 4, its nucleotide representation would be ACTGACTGTTAA and its amino acid representation would be ThrAspCysSTP.

Output

Your program must output its representation in amino acids.

Further Rules

All quines must also be valid proteins themselves. This means that:

• The quine has a number of nucleotides divisible by three
• The last three nucleotides are either TAG, TAA, or TGA, corresponding to a STP codon
• No STP codons appear anywhere but the end of the quine.

Apart from that, the standard rules apply.

Scoring

This is code golf, so the shortest code wins.

Notes/Questions for Sandboxing

Ok, so I get that it's rather short. Is my point clear? Is the scoring section clear? How about loopholes? Should I point out that printing a single STP is not allowed? Would that even be possible?

Answer 7

Create a Flip-Flop Program

Your challenge is simple: write a full program which alternates between two different outputs upon each run.

Your submission can choose which is printed the first time the program is run, but after that it should alternate between these exact outputs.

Rules/Details

• You cannot assume the filename of your program.
• The values must be distinct.
• Creating files is allowed - you are allowed to assume a file such as a.txt does not already exist in the directory.
• Reading and modifying the source is allowed.
• This is code-golf, so the shortest solution (in bytes) wins! Standard golfing loopholes apply.

Sandbox

• Should I allow assuming the program's filename at an additional bytecount (length of filename)?

code-golf stateful

Answer 8

Thou shall permute!

Given a string of upper and/or lower case letters and/or numbers (or list of characters if you want), and a list of permutation cycles, compute every intermediate step of applying this permutation under the following rules:

• The space to move letters around is one row above and one row below the input, with the same length available as the string length.
• In the beginning, top and bottom row are empty, and the middle row contains the whole string
• A character can only take the spot of another character, if that spot is empty
• There can only be at most one character in the top row and one in the bottom row at any time
• You can only move one character in one direction per state change. Directions are:
  1. Out of the middle top or down
  2. Left/Right (any number of steps at once)
  3. Into the middle

Cyclic Permutations

I'm assuming 0 based indexing. A list of cyclic permutations looks like this (I'm assuming list of tuples, but I don't mind if you want something else, as long as it conveys the same idea):

[(0,2,3),(1,4)]

This would mean that:

• index 0 goes to index 2, index 2 goes to index 3, index 3 goes to index 0
• index 1 goes to index 4, index 4 goes to index 1

Examples:

I'm using the -character to show available spots here, you may use a space or any character that can not be contained in the input string, such as #or $.

Given the string test and the cyclic permutations [(0,2)(1,3)], the steps would look as follows:

----
test  #Start state
----

----
-est  # Move index 0 out 
t---

--s-  
-e-t  # Move index 2 to the other side
t---

--s-
-e-t  # Move index 0 to where it needs to go
--t-

--s-
-ett  # Insert index 0 at index 2
----

s---
-ett  # Move index 2 to where it needs to go
----

----
sett  # Insert index 2 at index 0
----

----
s-tt  # Move index 1 out
-e--

---t
s-t-  # Move index 3 out
-e--

---t
s-t-  # Move index 1 to index 3
---e

---t
s-te  # Insert index 1 at index 3
----

-t--
s-te  # Move index 3 to index 1
----

----
stte # Insert index 3 at index 1. Done.
----

Here is the same example again, but this time using only one long permutation of all characters: [(0,2,1,3)] instead of 2 independent permutations:

----
test
----

----
-est
t---

--s-
-e-t
t---

--s-
-e-t
--t-

--s-
-ett
----

--s-
--tt
-e--

-s--
--tt
-e--

----
-stt
-e--

---t
-st-
-e--

---t
-st-
---e

---t
-ste
----

t---
-ste
----

----
tste
----

Rules

• You will only receive valid cyclic permutations
• Please indicate if you want 0 or 1 indexed permutations, either is fine
• You will only receive valid strings up to length 10
• Characters in the string are not guaranteed to be unique
• it does not matter which order every permutation is processed as long as they're all processed (that means start and end states are the same, and the above rules are always fulfilled)
• There will be at least one permutation in the list of permutations
• All permutations in the list of permutations have at least length 2
• The maximal length of one permutation is the length of the input string
• There may be some indices that are not part of any permutation
• No index is part of more than one permutation
• You need to output the first step, the last step and all intermediate steps
• You may have as many trailing newlines and spaces as you want
• You may output a 2 dimensional array or anything equivalent instead of printing every step, or you can also return a list of all states in the end
• You can also generate an animation if you like instead of printing sequentially
• Lowest number of bytes wins
• Standard loopholes are forbidden
• You can write a full program or function

Test cases

I implemented a very un-golfed version in python3 here (redirects to repl.it). That code contains 2 functions. find_cycles takes a string and a permutation of that string and computes the cycles to go from one to the other. shuffle does the shuffling. It takes the start string and the cycles. You can use these functions to validate your program.

code-golf permutation

Answer 9

Find and execute a program from the internet code-golf internet

You have some task to do, but you are too lazy to do it yourself. Your also to lazy to make a program to do it. So you are going to make a program that finds a program to do the task you want.

Select a programming language Q (which must be Turing complete).

Your program will:

1. Take an input task, as a string, and input, as a string.
2. Search codegolf.stackexchange.com, using the input string as the query
3. Select the first question in the search results with an answer which contains a valid Q program. (If there is no such question, the operation of your program may be undefined.) (You may assume that program is in a code block.)
4. Select either the accepted answer if it contains a valid Q program, or the highest voted answer that contains a valid Q program.
5. Execute the Q program that that answer contains, using the input from step 1.

Since you are lazy, you want your program to be the shortest program possible. So this is code-golf, shortest answer wins!

Answer 10

Information Masking

Email Address Masking:

Only show the first and last characters of the username components of an email address, along with email domain name. Include 5 stars in the middle of the username to mask the length. The username part of the email address may use any of the ASCII characters listed below.

Rules

1. Uppercase and lowercase English letters (a-z, A-Z)
2. Digits 0 to 9
3. Characters ! # $ % & ' * + - / = ? ^ _ { | } ~
4. Character . (dit, period, full stop) provided that it is not the first or last character, and provided also that it does not appear two or more times consecutively.
5. It is provided that email should end with @domainName.com, where the domain name has only alphabetic characters.
6. It is provided that email address username part have at least 2 characters not starting and ending with a special character.

Example

[email protected] --> j*****[email protected]

Phone number masking:

Rules

Mask all the digits in a phone number except the last 4 digits. Each number should be replaced by star(*). Input phone numbers can be with or without the country code. Input Phone numbers can only have +, (, ), - in them along with numbers and spaces. Make sure + is not masked in the output and make sure the number of stars is equal to the number of digits while masking.Phone numbers will always have 10 digits without country code and with the country code, they could be up to 13 digits.

Examples

Example1: +1 (333) 444-5678  --> +*-***-***-5678  
Example2: +91 (333) 444-5678 ->  +**-***-***-5678  
Example3: 333 444 5678 --> ***-***-5678  
Example4: (333) 444-5678 ---> ***-***-5678

Program input will start with E: for email and P: for phone numbers, ignore spaces if they are found in the input.

Complete Program Example

Input:

E: [email protected]  
P: +13334445678

Output:

E: j*****[email protected]  
P: +*-***-***-5678

Answer 11

Given an Integer array:

1. Start from the first number (n)
2. Go forward (n) positions depending on the current position
3. Delete the current position, the rest of the array fill in to the current position.
4. Goto step 2 until there are one number remaining
5. Print that number

The array loops around (the next number after the last number in the array is the first number).

A zero removes itself.

Negative numbers are not allowed as input.

Test Cases

[1] => 1
[1,2] => 1
[1,2,3] => 3
[1,2,2] => 1
[1,2,3,4] => 1
[6,2,3,4] => 4
[1,2,3,4,5] => 5
[0,1] => 1
[0,0,2,0,0] => 0

This is code-golf, the shortest answer in bytes wins!

---

Step-by-step example

[1,4,2,3,5]
 ^          start from the first position
   ^        jump 1 position (value of the position)
[1,  2,3,5] remove number in that position
     ^      take next position of the removed number
         ^  jump 2 positions
[1,  2,3  ] remove number in that position
 ^          take next position (looping on the end of the array)
     ^      jump 1 position
[1,    3,5] remove number in that position
       ^    take next position (looping)
       ^    jump 3 positions (looping on the end of the array)
[1,      5] remove number in that position
         ^  take next position
 ^          jump 5 positions (looping)
[        5] remove number in that position
print 5

Example #2

[4,3,2,1,6,3]
 ^            start from the first position
         ^    jump 4 positions
[4,3,2,1,  3] remove number in that position    
           ^  take next position
     ^        jump 3 positions
[4,3,  1,  3] remove number in that position    
       ^      take next position
           ^  jump 1 positions
[4,3,  1    ] remove number in that position    
 ^            take next position
   ^          jump 4 positions
[4,    1    ] remove number in that position    
       ^      take next position
 ^            jump 1 position
[      1    ] remove number in that position
print 1

---

Note: This is my first challenge so any input is welcome.

Answer 12

Golf a number

Create a program or function, which when given an input integer, outputs a mathematical expression evaluating to the same value. Expressions which require fewer bytes to represent than the integer itself will achieve better scores!

Explanation

It is often useful when golfing to compress constant integer expressions by expressing them in the form of an equivalent mathematical expression. 387420489 for example is much more efficiently expressed as 9^9. Similarly 4194303 as 2^22-1

The challenge is, for each integer in the range 1 to 1E6, to golf the number into as short an expression as you can (although any expression which evaluates correctly is acceptable output, see Rules below). The shorter the expression, the better your score; but short programs will also score well so the two need to be balanced!

Rules:

Input integer as argument or from STDIN

Output as string or equivalent to STDOUT or as function output. Your string can only contain ascii characters [0,1,2,3,4,5,6,7,8,9], as well as those operators defined below, repetitions allowed.

You may use the following mathematical operators any number of times in your string:

() parentheses
^ exponentiation
* multiplication
/ division
\ integer(floor) division - see Test Evaluator
+ addition
- subtraction

NB: division, integer division and multiplication are all evaluated with equal priority, so 3/2\2 = 0 whereas 3\2/2 = 0.5

You may output the input value (if it can't be golfed for example), you do not have to output the perfectly golfed string:

 In: 10000

Out: 10000
     10^4
     2^13+1808

However the output must evaluate exactly to the input (assuming perfect precision of floats)

Scoring

Answers are scored on their compression ratio (how much they golf the input down on average), as well as program size

Program Size: byte count of program (as with normal code golf)

Compression Ratio: golfed Length (white-space ignored) / input Length

Individual Score = (Compression Ratio * 100 - 70)/6 + Log(Program Size, base 10)

Final Score = Mean score for first 10^6 integers

Lowest final score for each language wins!

Tags:

expression-buildingcode-challengearithmetic

---

Sandbox:

related

related

The main sticking point is scoring how best can you combine 2 metrics into a single score?

The logic so far is that compression ratios will lie in the range 100 - 70 % where 100 is returning the input. Program lengths should be between 2 extremes; returning the input (1 byte) and looking up the input in a hardcoded list (~19,000,000 bytes). This gives the following distribution:

Actual program length I guestimate will be anywhere in the range 1 to 10000 bytes, hence the log to make the range more manageable. Quick reference; I could probably implement all power golfing (expressing n as a^b) in ~100-200 bytes in VBA. So 10% of that for golfing languages, and who knows what builtins Mathematica has ;).

But implementing more effective algorithms may require a more verbose language, so I think 1 - 10000 seems like a good range to handle in scoring

Open to alternative scoring though, and any required clarifications. Also suggestions what is a good range to test over?

I've suggested 1 to 1E6; The first 1000 integers I don't think are golfable, after that only a few are. So perhaps a greater range of test cases, or ones starting at a larger initial value? What's the biggest range I can feasibly test within say, 10 mins running time max? What's typical algorithm execution times can be expected per digit? I don't want golfers to have to spend too long generating their average score...

Test String Evaluation

Answer 13

All possible distributions of different items of a set to an arbitrary number of groups

See Descriptive Real World Example, Rules / Edge Cases or Sample Data for an idea about this or help me by adding a nice sentence explaining it while this is in sandbox.

Descriptive Real World Example:

Ordering a set of x items from a shop what are the possibilities to distribute them among 1 to x orders?

Rules / Edge Cases

• Identical items are not being distinguished (AB, B == AB, B, compare examples #4, #5 and #6)
• Order is not important
  • Order of items in order/group: AB == BA
  • Order of orders/groups in distributions: A, B == B, A
  • Order of possible distributions (i. e. lines among output)

Format

I don't really mind the exact format but as it probably makes sense (right?) to tie oneself down to one format I'll suggest the following:

• Input: Set of items without delimiters. Supported chars: [A-Za-z0-9]
• Output:
  • Hierarchy: Distributions (Orders (Items))
  • Delimiters:
    • Among distributions in overall output: EOL
    • Among orders/groups in distribution: Comma, Space
    • Among items in orders/groups: None

Sample Data

╔═════════╤═══════╤═════════╤════════════╗
║ Example │ Input │ Output  │   Output   ║
║   Nr    │       │ line nr │   lines    ║
╠═════════╪═══════╪═════════╪════════════╣
║   #1    │ A     │    1    │     A      ║
╠═════════╪═══════╪═════════╪════════════╣
║         │       │    1    │    A, A    ║
║   #2    │ AA    ├─────────┼────────────╢
║         │       │    2    │     AA     ║
╠═════════╪═══════╪═════════╪════════════╣
║         │       │    1    │    A, B    ║
║   #3    │ AB    ├─────────┼────────────╢
║         │       │    2    │     AB     ║
╠═════════╪═══════╪═════════╪════════════╣
║         │       │    1    │  A, A, A   ║
║         │       ├─────────┼────────────╢
║   #4    │ AAA   │    2    │   AA, A    ║
║         │       ├─────────┼────────────╢
║         │       │    3    │    AAA     ║
╠═════════╪═══════╪═════════╪════════════╣
║         │       │    1    │  A, A, B   ║
║         │       ├─────────┼────────────╢
║         │       │    2    │   AA, B    ║
║   #5    │ AAB   ├─────────┼────────────╢
║         │       │    3    │   AB, A    ║
║         │       ├─────────┼────────────╢
║         │       │    4    │    AAB     ║
╠═════════╪═══════╪═════════╪════════════╣
║         │       │    1    │  A, B, C   ║
║         │       ├─────────┼────────────╢
║         │       │    2    │   AB, C    ║
║         │       ├─────────┼────────────╢
║   #6    │ ABC   │    3    │   AC, B    ║
║         │       ├─────────┼────────────╢
║         │       │    4    │   BC, A    ║
║         │       ├─────────┼────────────╢
║         │       │    5    │    ABC     ║
╠═════════╪═══════╪═════════╪════════════╣
║         │       │    1    │ A, B, C, D ║
║         │       ├─────────┼────────────╢
║         │       │    2    │   AB, CD   ║
║         │       ├─────────┼────────────╢
║         │       │    3    │   AC, BD   ║
║         │       ├─────────┼────────────╢
║         │       │    4    │   BC, AD   ║
║         │       ├─────────┼────────────╢
║         │       │    5    │  A, BC, D  ║
║         │       ├─────────┼────────────╢
║         │       │    6    │  B, AC, D  ║
║         │       ├─────────┼────────────╢
║         │       │    7    │  C, AB, D  ║
║         │       ├─────────┼────────────╢
║   #7    │ ABCD  │    8    │  A, CD, B  ║
║         │       ├─────────┼────────────╢
║         │       │    9    │  A, BD, C  ║
║         │       ├─────────┼────────────╢
║         │       │   10    │  B, AD, C  ║
║         │       ├─────────┼────────────╢
║         │       │   11    │   ABC, D   ║
║         │       ├─────────┼────────────╢
║         │       │   12    │   BCD, A   ║
║         │       ├─────────┼────────────╢
║         │       │   13    │   CDA, B   ║
║         │       ├─────────┼────────────╢
║         │       │   14    │   DAB, C   ║
║         │       ├─────────┼────────────╢
║         │       │   15    │    ABCD    ║
╚═════════╧═══════╧═════════╧════════════╝

Answer 14

Show me your core

On many 8-bit machines, it is relatively easy to output the entire core syntax of the built-in language, as everything required is in ROM and most 8-bit machines allow you to PEEK at each location therein, or otherwise easily access the ROM contents.

Here's the complete syntax for a Sinclair ZX81 or Timex TS1000/1500 machine as an example:

 1 PRINT CHR$ 64;CHR$ 65;CHR$ 66;CHR$ 193;CHR$ 193;
 2 FOR I=196 TO 255
 3 PRINT CHR$ I;
 4 NEXT I

Is it as easy to output the core or standard syntax to a screen, console, or window in modern-days languages? How best would I word such a question? And would this make a good challenge?

Answer 15

Sight Matrix

code-golf matrix number

---

I haven't seen this done anywhere yet after a couple of searches, so I might as well post this anyways. If you see this done somewhere else, please tell me and I will delete this post.

The Story

You are a two meter tall sniper fighting in a war-torn area. Your teams have just beaten back the enemy, but the guerillas have an annoying habit of hiding out of sight and waiting patiently to take your unit by surprise, often inflicting heavy casualties. You have been tasked with dealing with these guerillas as a sentry.

The Task

Summary

Write a program that, when given a n x n 2D matrix of heights (in meters), outputs a n x n 2D binary matrix with ones being areas that you can see and zeroes being areas that you cannot see.

Input Format

The input will be a two-dimensional array of heights and two numbers signifying where you are standing.

Output Format

The output will be a two-dimensional array of ones and zeroes: ones where you can see and zeroes where you can't see.

Sample input/output

Input:

[[120,87,89,93,121], [120,91,83,91,114], [118,121,90,93,97], [124,129,115,120,101], [117,140,138,124,99]] 0 0

Output:

[[1,1,1,1,1], [1,1,1,1,1], [1,1,1,1,1], [0,0,1,1,1], [0,0,0,0,1]]

Hint:

Last time I checked, people's eyes were on their head. Put that into account when you are writing your code.

---

This is code-golf. Shortest answer in bytes wins. Standard loopholes apply.

Note: this is my first foray into code-golf stackexchange. Please tell me how to improve this or things that I need to add to this answer.

Answer 16

Output One More than Int Max code-golf arithmetic integer

Your job is to create a program or function that will output a whole number (with no trailing decimal point) that is 1 greater than the max number an integer can hold for the language; more or less this:

MAX_INT + 1

You are not allowed to use Strings in your solution. Any other type may be used.

Shortest answer in bytes wins.

Note: I know this might be impossible in some languages. I have verified that it is possible in at least one (un-disclosed) language.

---

Notes on this puzzle

I posted this puzzle recently here and it promptly got closed and deleted (oops). Thankfully, @WheatWizard was kind enough to explain what some of the confusion was. Here where his comments:

I've voted to close this question as unclear. There are a couple of things I find especially unclear, 1) I'm not sure what "the max number an integer can hold for the language" means, it definitely needs a more concrete definition. It seems to presuppose some bounded "integer" type in the language. All the existing answers seem to suppose that long (or equivalent) is not this integer type but that is not at all clear from the question.

2) The requirement "You are not allowed to use strings in your solution" is neither clear nor enforceable. Without a rigorous definition of string there is no way to determine what is a string or not. For example Prolog has a type called "String" but all real string manipulation is actually done on lists of char codes. Are those strings? Prolog also has atoms which behave a lot like strings in many ways, (and act like integers in others) are they strings?

The main thing I would want to see before retracting my close vote/voting to reopen is clear definitions of the terms in question. To be clear that is a very tall order. These terms are not going to be easy to define, let alone define well. I would recommend temporarily moving this question to the sandbox so that you can workshop it a bit.

@Xcali said the following:

To follow on @WheatWizard's comment, what about languages where there's really no type to a variable. For example, in Perl, any single value may be treated as a string or a number at any time

And @Adám:

@CalebKleveter I think you can fix your challenge by removing the prohibition on strings and requiring documentation and/or additional supporting code showing that the produced number cannot be held as any type of integer. Do you want me to edit your post accordingly?

Are there any suggestions on how we could define the things pointed out in these comments? Are there any other issues that should be resolved?

Answer 17

Als pr Yrck, I knw hm Hrtio

Here is a link to a text file containing the script for Shakespeare's Hamlet.^{[to do: provide such a text file, or think of another freely available text input that leads to a wittier title.]}

Your task is to write a program that will compress this text, and another that will decompress it to return exactly the original file. Your score is given by C + D + 0.5*F, where C is the size of your compression program, D is the size of your decompression program, and F is the size of the file that your compression program generates, all measured in bytes. The smallest score wins.

Further particulars

Your compression program should take hamlet.txt as input and produce a single file as output, which is to be given as input to your decompression program. You should make sure that the resulting output from your decompression program is identical to the original hamlet.txt file, e.g.

> myCompressor hamlet.txt > compressed
> myDecompressor compressed > output.txt
> diff hamlet.txt output.txt
[no output from diff command means they are identical]

Your programs' only purpose is to compress and decompress the hamlet.txt file - their behaviour on any other input is not part of the challenge. It's fine, for example, if the decompressor always outputs the text of Hamlet regardless of the original input, or if the compressor crashes on any input besides hamlet.txt.

Input and output can be by file I/O or STDIN/STDOUT or any other reasonable method, but the compressor and decompressor should be full programs. They need not be written in the same language.

Your compressor and decompressor must each be completely self-contained. Each must consist of a single file, and that file must be the source code for a programming language as defined here. With the exception of importing libraries, your compressor and decompressor must not open any other files besides their input.

The compressed file may be a text file or a binary file - the only thing that matters is its size in bytes. No information may be transmitted from the compressor to the decompressor by any means other than the content of this file.

You may not use any libraries or built-ins that implement data compression algorithms, such as gzip or bz2, or their corresponding decompression algorithms. This restriction only applies to "off the shelf" implementations - you can use any algorithm you like if you implement it yourself. For details on what counts as a data compression algorithm, see note 1.

If for some reason your language or libraries include a feature that outputs some or all of the text of Hamlet, you may not use that feature.

Although it's not part of the challenge, you are encouraged to explain/demonstrate what happens when your compressor is given some other input besides hamlet.txt, especially if it does something interesting such as produce a garbled Shakespearean version of the input text.

_{Note 1: For the purpose of this challenge, a data compression algorithm is anything listed in Wikipedia's Category:Lossless Compression Algorithms or Category:Lossy Compression Algorithms, or any of their subcategories. Note that these lists can change over time, and if Wikipedia's editors will allow a new item to be added then that will count as a compression algorithm, even if that happens after an answer using it is posted. This is to prevent the use of obscure algorithms that are not yet listed on Wikipedia. Editing Wikipedia to get around the restriction on off-the-shelf compression is not allowed.}

_{This rule is intended to prevent the use of existing algorithms while allowing all other language features and built-ins. It may be the case that some items on the Wikipedia list are overly broad and end up banning common language features. If this is the case I will add exceptions on a case-by-case basis. This will only be used to permit things that would otherwise be banned, so it won't invalidate existing answers.}

---

Sandbox note: the really tricky thing here is how to prevent trivial solutions that just wrap an existing compression algorithm, without also banning common language features. The above Wikipedia-based definition of a compression algorithm is a bit experimental and I'd welcome feedback on it. My intention is to prevent trivial solutions that just wrap an existing implementation of a compression algorithm, while allowing pretty much anything else.

Another possible approach is simply to allow anything and hope that answers specialised to the input can achieve better scores. That's effectively what I did in Paint Starry Night, but in the end I wish I hadn't, because it turned out that (so far at least) even really clever solutions based on neural nets and genetic algorithms can't come close to the off-the-shelf BPG algorithm. That's the sort of situation I want to avoid for this challenge.

Answer 18

Your Task:

To create a piece of code that takes in an input, and outputs ASCII art, which is encoded in the input string.

It seems unclear, but you are basically creating your own programming language that takes a piece of code in a syntax that you create, and then writing a code that takes that input, and turns it into ASCII art.

---

Example:

A simple example would be an input that runs through a line of input code with the syntax:

0 : An empty space
1 : A space that is occupied
2 : A newline character

I:

01010210101201010210101201010

O:

 The '|' character is just to show the matrix

| # # |
|# # #|
| # # |
|# # #|
| # # |

I:

11112000121111210002111122 // Shows a 2
11112100121001210012111122 // Shows a 0
0120120120120122 // Shows a 1
11112100121111210012111122 // Shows an 8

O:

####   
   # 
#### 
#  
#### 

####
#  #
#  #
#  #
####

 #
 #
 #
 #
 #

####
#  #
####
#  #
####

The code would read through the letters one by one and print out the characters, or create a newline character as expected.

---

Since this is code-golf, the code with the fewest bytes wins!

Answer 19

Stem and Leaf

A stem-and-leaf plot is a way to represent data and visualizing distribution. Usually the data is grouped in step of 10, with the last digit as "leafs" in ascending order, and the remaining digits as "stem". The steam and leafs are separated with a vertical line, with stem on the left and leafs on the right.

Challenge

Make a program or function which takes a list of non-negative integers as input, and outputs the corresponding stem-and-leaf plot.

Example Input and Outputs

Example 1:

Input: 10 2 15 4 2 24 18 17 24 24 25 15 18 22 17 23 24 33 19 28 28 28 26 32 25 27 37 28 41 38 38 30 35 30 41 45 40 40 37 33

Output:

0|224           
1|05577889      
2|23444455678888
3|0023357788    
4|00115

Example 2:

Input: 112 101 116 99 99 107 101 99 115 112 114 128 115 119 125 160 148 147 159 147 169 160 163 160 160 163 162 164 160 173 84 92

Output:

 8|4
 9|2999       
10|117       
11|2245569   
12|58        
13|
14|778       
15|9         
16|0000023349
17|3

Rules

• The input may be a list, an array, a space or comma delimited string or other appropriate representation containing raw data values.
• The vertical line of the output must be aligned.
• A leading or trailing newline, or trailing spaces for each line are accepted.
• Common loopholes applied.

This is a code-golf challenge, so the lowest-byte solution for each language wins!

Answer 20

Imagine you're a dishonorable scientist trying to prove that getting heads on a coin flip actually has about 70% probability when flipped 100 times. The trick is, you're going to flip the coin an arbitrarily large number of times (say, a million) and select the slice of 100 flips that contains the most number of heads. As input, take the number of total trials to do, and as output, return the number of heads contained within the most favorable contiguous slice of 100.

Answer 21

Find a Path of Similar Proportions!

code-challenge

Given a point on a square lattice, find the shortest path (by jumps) from the origin to that point, following these rules:

• You are allowed to make any number of jumps containing any number of steps along the grid lines to another lattice point. These jumps must be along the grid lines and have an integer length.
• Each jump must contain one step more or be one step shorter than the step before it. (This is where the "similar proportions" comes into play. Name change pending?)
• The first step can have any length.

As an example, here is how one possible way one might travel from A(0,0) to B(5,5) under these rules:

A
|
|
|
1----2
     B
     |
     |
     3

The numbers indicate which steps are taken. Note that this solution backtracks, moving to (5,8) before partially retracing its path to get to its destination. This solution takes four jumps and is therefore optimal.

Here is a diagram of the number of jumps required for the shortest (or is it?) path to any other point with both integer coordinates below or equal to 10. Note the symmetry around (x,x). I don't know if my solution for (7,10) is optimal.

  | 0  1  2  3  4  5  6  7  8  9  10
--------------------------------------
0 | 0  1  1  1  1  1  1  1  1  1  1
1 | 1  3  2  3  3  3  3  3  3  3  3
2 | 1  2  3  2  3  3  3  3  3  3  3
3 | 1  3  2  3  2  3  3  3  3  3  4
4 | 1  3  3  2  4  2  3  3  3  3  3
5 | 1  3  3  3  2  4  2  3  3  3  3
6 | 1  3  3  3  3  2  4  2  4  3  3
7 | 1  3  3  3  3  3  2  4  2  4  5?
8 | 1  3  3  3  3  3  4  2  4  2  4
9 | 1  3  3  3  3  3  3  4  2  4  2
10| 1  3  3  4  3  3  3  5? 4  2  4

The actual actual task

Your task is to continue the table for points with coordinates as large as (127,127).

Your submission should be a program which prints valid paths for all points whose two coordinates lie between 0 and an inputted positive integer inclusively, or a function, which, given any pair of positive integers, outputs a valid path to the point specified by these coordinates.

A valid output path is an array or list (or other comparable datatype) which uniquely represents a valid sequence of jumps that can be used to reach the specified point and which makes it as easy as possible to find the number of jumps required.

Example possible ways for the example path given above:

[["d", 4], ["r", 5], ["d", 4], ["u", 3]] // using chars to represent direction
[[0, 4], [5, 0], [0, 4], [0, -3]] // direction vectors
[0, 4, 5, 0, 0, 4, 0, -3] // As above, in just one list. len()/2

Scoring

Your submission will be scored by the sum of your solution's bytecount and the sum of all jump counts for all paths it outputs for reaching any point between (0,0) and (127,127), inclusively. Smallest score wins, standard rules and loopholes apply, etc...

Example response (Python 3):

def c(a,b):
    d,e,g=[[a,0]],a+1,0
    while not g==b:
        d.append([0,e])
        e,g=-e+1,g+e
    return d

This extremely simple and naive piece of Python code achieves a score of 92 (program length) + 1406272 (for the path part) = 1406364, as verified here - Try it online!

More?

• missing tags?
• clarifications?
• Table is incorrect?

Please respond.

Answer 22

Collectables, Inc king-of-the-hill

You're an aspiring collector. You want to be the top collector for as many collections as possible.

Here's how you play (with P players):

• The game consists of multiple Auctions, and 2P collections. Some collections are bigger than others. Smaller collections are more valuable and rare, bigger collections are cheaper.

• Each Auction puts 2P random items up for sale

• You place a bid on each item, grouped by collection. (e.g. If doll was a collection, you place a single bid for all of the dolls in the current Auction)

• You win by having the most pieces for the most collections. (Each collection is worth 1 point. If you have the plurality of that collection, you gain that point).

Fine Details:

• Players start with 30 gold.

• Each collection contains a different number of items, from 2 to 2P+1.

• There are 2P+3 auctions (until all items are sold)

• Players can bid on multiple items, and their total bid can exceed their current gold.

• Resolution of bids happens as follows:

  1. All invalid bids are removed. (Players without enough gold, or bids on items already sold).
  2. Find the top bid (by gold). Tiebreaker is the collection size (smallest first).
  3. If there is still a tie, then that item group is removed.
  4. Otherwise, the top bidder wins the item group. His money is added to the pot.

• After an Auction is finished, the pot is evenly distributed among all players. Any remainder is put back into the pot.

I think that my rules are pretty complete.

• Is it clear?
• Is it interesting?
• How many reads did it take you to understand the post?

Answer 23

Unicode reversible programs

The goal is to make a program that includes unicode formatting characters that when executed as-is generates a OEIS sequence, and when copied as its rendered* and executed, returns a different sequence.

• The renderer is one that properly reacts to unicode formatting. For example with RLO the text should be reverted. (Its stored as "\u202etest" but renders as "tset"

This is will be code-golf so the answer with less bytes wins.

Answer 24

Non-true, non-false JS boolean

Array prototype isn't redefined, input hasn't getters

function magic(input){
  let result = [];
  if(input.boolean != true){result.push("non-true");}
  if(input.boolean != false){result.push("non-false");}
  result.push(input);
  return result.join("\n");
}

returns

non-true
non-false
{"boolean": true}

What is passed to magic function?

Based on real problem :) I spent 30 minutes on this puzzle

Answer 25

Tags: Codegolf

Title: evil detection

When given any (you may choose the format and you should assume integer input) input, the output should be true if the input is a palindrome and false if not (or 1/0 or any equivalent).

To make it (a lot) harder, your code must work with a result that fulfills the challenge inverted if read backwards. So for a palindrome input, forward gives true, backwards false.

Example:

If your code is "abc12" and the input is 1221, your code should produce true-ish and "21cba" (your code read backwards) should produce false-ish.

Bonus if you think that's to easy: produce false if and only if the input is 666 forward and true backwards.

Answer 26

Build a Brainfuck transpiler

Your job is to build a program that transpiles valid brainfuck to a language (not brainfuck!) of your choice.

You are not required to handle cases where the program is invalid (mismatched [ ]s), or contains characters that are not +-<>[],. but all other cases must be handled.

Size limits on your input or output are fine as long as they are imposed by computer restrictions, like RAM.

The programming language you transpile to is covered under the "What defines a programming language" rules, and must have been created before this challange.

In extension to not transpiling to brainfuck (cheater!) you can't use a brainfuck derivative or trival brainfuck substitution as the transpiled to language either.

Scoring

Programs will be scored with the average ratio of bytes in the input brainfuck program to the output transpiled result, as based on the examples.

Meta questions

This is a rough draft!
What tags should be associated with this?
How can I improve the scoring system?
What examples should I use to keep the scoring fair, but prevent obvious tricks?
What loopholes are there in this rough draft that I need to patch?

This entire thing will be reorganized when I get enough info to make a better writeup.

Answer 27

Chiasmus Indenter

string code-golf

---

Chiasmus is a literary form that is similar to palindromes. Some ideas are presented and then presented again in reverse order, often phrased differently.

Natural language processing is hard, so I'll be using a more computer-friendly definition. A chiasmic string is made up of a series of substrings that are repeated in reverse order in the second half of a string. Formally:

• If a is some non-empty string, then aa is chiasmic.
• If C is chiasmic and a is some string, then aCa is also chiasmic. Note that this applies recursively, thus abCba is chiasmic if C is also chiasmic and a and b are non-empty strings.

For example, batbat is chiasmic, as are glassbottlebottleglass and AliceBobCharlieCharlieBobAlice. All even-length palindromes are chiasmic, being made up of many length-1 strings.

Note that the empty string is not a chiasmus.

The Challenge

We're programmers, so we like nice indentation. Your goal is to take chiasmic strings and indent them so that each matching substring is at the same level of indentation. For example, cheesepizzawithanchoviesanchovieswithpizzacheese would be indented like so:

cheese
    pizza
        with
            anchovies
            anchovies
        with
    pizza
cheese

For base case chiasms (i.e. 2 repetitions of a string), no indentation is necessary, but the substrings should still be on separate lines. Thus, gumgum would be indented:

gum
gum

In order for there to be only one canonical output for each chiasmus, if it is possible to indent at more than one place, indent in a way such that the a substrings for the form aCa are as long as possible (applied recursively for each C until the aa base case is reached). For example, catdogcatdogdogcatdogcat should be indented like this:

catdogcat
    dog
    dog
catdogcat

Not like this:

cat
    dog
        cat
            dog
            dog
        cat
    dog
cat

Also not like this:

cat
    dogcatdog
    dogcatdog
cat

The behavior of indenting a non-chiasmus is undefined.

Rules

• Indentation can use any amount of whitespace of any kind, so long as it is consistent (e.g. do not mix tabs and spaces). Lines may either be output as a list/array/whatever or a newline-separated string.
• You may assume that the input is a chiasmus that contains only alphanumeric characters.
• As this is code-golf, the shortest submission wins.

Answer 28

Self-removing executable (retracted: dupe)

Answer 29

Convert a number to (Name-To-Be-Specified)

(Name-To-Be-Specified) is a completely made up language. It uses a Senary (base 6) system of numbers with words for those numbers structured in a similar way to English.

0 to 6
Single digit numbers use a single word for each digit.

0 = "zeeroo"
1 = "nimbo"
2 = "feta"
3 = "tarumba"
4 = "ntamno"
5 = "waramaka"
(Any similarity to Kómnzo numbers are coincidental.)

6 to 11
The first set of two-digits numbers have special rules.

6 = "wi"
7 = "seeveen"
8 = "ayte"
9 = "tarumbawin"
10 = "ntamnowin"
11 = "waramakawin"

12 to 35
Multiples of 6 have the single digit word with a "wee" suffix.

12 = "fetawee"
18 = "tarambawee"
24 = "ntamnowee"
30 = "waramakawee"

Other numbers in this range are made by joining the word for the multiple of 6 with the word for single digit number, separated by a space. For example:
13 = "fetawee nimbo"
20 = "tarambawee feta"
27 = "ntamnowee taramba"
34 = "waramakawee ntamno"

36 to 1295
1296 to 46655
46656 to 1679615
1679616 to 60466175
(Since this is a sandbox, I'll leave these to-be-specified for now. Suffice to say I'll come up with words for each and consistent rules for joining them together and when you need the word "and".)

Challenge

Write a program that takes an integer as input and outputs that number in (Name-To-Be-Specified) words as described above. Shortest code wins.

Answer 30

Paintball Tournament

Inspired by The Rock, Paper, Scissors, Lizard, Spock Tournament of Epicness as well as other King-of-the-hill challenges, I would like to propose a Paintball Tournament.

There is a game on my phone, called Game Pigeon that contains a paintball game. This paintball game is played by two players. The object of the game is to shoot your opponent x times before they shoot you x times.

Gameplay

The game is played in two sets of rounds. A moving round and a shooting round.

Both players, without their opponents knowledge, pick from three objects in front of them to hide behind.

                                (P1) X           X
                                     X           X (P2)
                                     X           X

Both players, without their opponents knowledge, choose which target across from them they would like to shoot at. After players decide which target to shoot at, players shoot at the targets chosen in unison, during which expose themselves from behind their target and are vulnerable to be hit.

Let's go through a small example. In the movement round, P1 has chosen to hide behind their left-most target. P2 has chosen to hide behind their middle target. In the shooting round, P1 chooses their leftmost target (Spot 1). P2 chooses their rightmost target (Spot 3). (See Below for diagram)

                                (P1) 3 <- Hit   1
                                     2          2 (P2)
                                     1  Miss -> 3      

For the above example, P1 would miss their shot and P2 would hit their shot, resulting in P1 losing one of their lives. During the shooting phase, players must choose a barrier to shoot behind, they cannot stay hidden.

After the shooting phase both players go back into the moving phase and, without their opponents knowledge, can move behind either of the other two objects or stay in place. They then continue to the shooting phase. They loop through these two phases until one of the players run out of lives, both players run out of lives, or a set number of rounds is completed.

Inputs

In the first game of the match, no arguments will be supplied to your bot. In each subsequent game of the match, you will be supplied 2 Args. -Arg1 will contain the location of the player([1, 2, or 3]) as well as the players move history. -Arg2 will contain the location of the players shot([1, 2, or 3]) as well as the players shot history. Both of these locations are referenced as if you are looking in the face of your opponent.

Example:

• Round 1: PaintballBot.exe
• Round 2: PaintballBot.exe 1 1
• Round 3: PaintballBot.exe 12 11
• Round 4: PaintballBot.exe 121 113

Output

Each round, your bot must output the location in which it is hiding, and the location it is going to shoot, to STDOUT, with two characters. All example outputs are shown below:

11 12 13 21 22 23 31 32 33

Match Format

Each submitted bot will play one match against each other bot in the tournament

Each match will last until one of the players loses their x amount of lives, or the match executes 50 rounds.

Matches will be played anonymously, you will not have an advanced knowledge of the specific bot you are playing against, however you may use any and all information you can garner from his decision making during the history of the current match to alter your strategy against your opponent. You may also track history of your previous games to build up patterns/heuristics etc... (See rules below)

Submission

Your submission should include:

• Your Bot's name
• Your Code
• A command to
  • execute your bot from the shell e.g.
  • ruby myBot.rb
  • python3 myBot.py
  • OR
  • first compile your both and then execute it. e.g.
  • csc.exe MyBot.cs
  • MyBot.exe

Sidenotes

• Need to describe that the location is relative to the shooter(from left to right) and the targets are relative to the shooter(from left to right)

• I am still working on the control program for this event, and any help from other is greatly appreciated

If someone with more experience than me wants to take this over, please let me know. I would rather help with this challenge since it is my first and then have the knowledge and skills to run my own in the future.

Please let me know what still needs more clarification so we can have a fun tournament!