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

OCR

test-battery code-challenge

In this challenge you will attempt to write a program to perform OCR in the fewest bytes possible. The tests are linked below, the only data that your program receives is the contents of the image, you may not rely on file name, timestamp, or other metadata, additionally you may not query any external source such as the internet or dispatch an independent program to outsource the task of OCR.

Spec

Given a hand written word in in image of 80px in height. Output the word. words will consist of lowercase latin letters:

abcdefghijklmnopqrstuvwxyz

Scoring

Given the test cases, your score is a percent of the words you have gotten correct. No partial credit.

---

Tests cases:

TODO

Answer 2

Data exfiltration

Frenzy in the frequency domain.

Summary of the challenge

You must find a way to broadcast a ten-character password through a lossy communication channel and recover the password on the other side. To achieve this you must write two programs. The first program will receive the password as input and encode it as output data for the channel, the second program has to decode the output of the channel back to the password.

Some background

In signal processing theory, many problems are usually dealt with by converting a signal from the time domain to the so-called frequency domain, a trick that relies on the fact that any function can be written as an infinite series of sine waves. Signals can be converted into this domain using a Fourier transform. This transform is lossless, and the resulting signal can be converted back into the time domain using the inverse Fourier transform. The frequency domain has some interesting properties, as the actual values of the signal in it represent the amplitude and phase of different frequencies in the original signal.

A special case exists for when the signal exists out of equally spaced sampled points, called the discrete-time Fourier transform. To perform this transform the fast fourier transform algorithm is commonly used. Given a signal of N samples spaced with dt spacing, it will convert it into a signal containing N frequency bins which are each 1/(N*dt) apart.

Channel definition

The communication channel requires 256 unsigned bytes data as input, and returns 256 unsigned bytes data as output. If the input values are centered around zero and interpreted as data samples on regular intervals, then the output values represent the amplitude of the signal in the frequency domain scaled to use the range 0 to 255, calculated using a discrete fourier transform. The channel is lossy as it only transfers the amplitude of each frequency, not the phase.

It can be simulated using the following python 3 script:

import cmath
def channel():
    # amount of input and output values
    l=256
    # read the input values from standard input as newline separated integers and center them around zero
    n=list(map(lambda: min(255, max(0, int(raw_input())))-127.5, range(l)))
    # perform a discrete fourier transform
    v=[sum(v*cmath.exp(-2.0j*cmath.pi*t*k/l)for t,v in enumerate(n))/l for k in range(l)]
    # remove artifacts due to the Nyquist limit
    v[1:128]=map(lambda n:n*2,v[1:128])
    v[129:]=[.0]*127
    # return the scaled magnitude of each frequency bin
    for i in v:print(int(round(abs(i)*cmath.pi/2)))

Input/Output

The password is randomly generated using only using visible ASCII characters (0x20 up to and including 0x7E) and is 10 characters long.

Inputting the password to the encoder, communicating it to the channel, receiving data from the channel and communicating the decoded password should all follow the default input/output rules. The password must be decoded only from data received from the channel, no side-channels are allowed.

Scoring

This is code-golf, where the score is calculated by adding the length of both the encoder and decoder program. For each language, the shortest entry in bytes wins.

Meta

• Is the challenge clear
• Is the difficulty okay
• Anything else?

Tags: code-golf

Answer 3

List My Factors!

code-golfmath

---

Introduction

Given an algebraic expression as input, list all the factors of it. A factor of an algebraic expression is any algebraic expression (or simply a numerical expression, sometimes) that evenly divides it. A factor can only be an integer or an algebraic expression consisting of integers and variables.

---

Rules

• The algebraic expression will contain * to denote multiplication.

• The algebraic expression will only contain integer constants and coefficients.

• The algebraic expression will contain ^ to denote exponentiation.

• The algebraic expression will only contain positive constants, coefficients and variables.

• Your program should output only the positive factors.

• The algebraic expression will not contain negative exponents.

• You must not use any built-in to accomplish this.

• Standard Loopholes apply.

---

Examples

The algebraic expression 5*x^2 has the following factors:

1. 5
2. x
3. x^2
4. 5*x^2
5. 5*x
6. 1

The algebraic expression 10*(x-y)^2 has the following factors:

1. 10
2. 5
3. 2
4. 1
5. (x-y)
6. (x-y)^2 or x^2 + y^2 - 2*x*y
7. 2*(x-y)^2 or 2*(x^2 + y^2 - 2*x*y) or 2*x^2 + 2*y^2 - 4*x*y
8. 5*(x-y)^2 or 5*(x^2 + y^2 - 2*x*y) or 5*x^2 + 5*y^2 - 10*x*y
9. 10*(x-y)^2 or 10*(x^2 + y^2 - 2*x*y) or 10*x^2 + 10*y^2 - 20*x*y.
10. 10*(x-y) or 10*x - 10*y
11. 2*(x-y) or 2*x - 2*y
12. 5*(x-y) or 5*x - 5*y

The algebraic expression x^2 - y^2 has the following factors:

1. 1
2. x-y
3. x+y
4. x^2 - y^2

---

Input

Your program may take the input in any way except assuming it to be present in a predefined variable. Reading from file, input box, modal window, command line etc. is allowed. Taking input as function argument is allowed as well.

---

Output

Your program should output a list of factors of the given input as a collection data type (such as array) or as a separator-separated String.

Your program may output in any way except writing the output to a variable. Writing to file, screen, modal window, command line etc. is allowed. Outputting using function return is allowed as well.

---

Test Cases

Input               Output

5*x^2               [5*x^2, 5, 1, 5*x, x, x^2]
10*x^2              [10*x^2, 10, 5, 2, 1, 10*x, 5*x, 2*x, x, 5*x^2, 2*x^2, x^2]
10*(x-y)^2          [10*(x-y)^2, 10, 2, 5, 1, 10*(x-y), 5*(x-y), 2*(x-y), (x-y), (x-y)^2, 2*(x-y)^2, 5*(x-y)^2]
x^2 - y^2           [x^2 - y^2, x+y, x-y, 1]

---

Winning Criterion

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

---

Sandbox

1. Should I allow negative constants and coefficients? Answer : No
2. Should I allow variable exponents?
3. Is there any mistake in Examples and Test Cases?
4. How long should I let this challenge be here?
5. Any problem with the Input/Output Rules?
6. Should I allow built-in to accomplish the task?
7. Any other suggestion?

Answer 4

Rotational Anagrams

Given, for lack of a better word, an anagram cube c with n rings and a word w, output whether or not you can rotate the individual sections to make w appear across the middle.

Constraints

• The letters that can appear are all printable ASCII characters EXCEPT for newlines.
  • All three characters that make up the rings can appear (|-+).
• Your program should work for cubes of any size, though the maximum I expect you to test is my biggest case (this means that if your code won't finish for n=22 on TIO, I don't care).
• Your only input should be the ASCII-art c and the word w.
• Your only output is one of two distinct values for true/false, which are arbitrary.
• You can assume the input is well-formed, and output anything for bad input.

Examples

Example cube with n=3 and w='AXMOZC':

+----A----+
| +--Y--+ |
| | +N+ | |
B X M O Z D
| | +P+ | |
| +--W--+ |
+----C----+

Rotate the outer wheel once coutner clockwise:

+----D----+
| +--Y--+ |
| | +N+ | |
A X M O Z C
| | +P+ | |
| +--W--+ |
+----B----+

Ding-ding! A match, so we can output truthy for this, but for AXMOYC there is no rotation that allows that combination, so it would return falsy. (X and Y are not adjacent on the ring, which means they can't appear at the same time.

---

Here's a small cube of n=2:

+--G--+
| +P+ |
P C P G
| +C+ |
+--P--+

For an input w=PPCG|GPCP|PCPG|GCPP this returns true, everything else is false. So you can start to see that the possible keyspace of answers is always n**2, so... hint hint.

---

Here's the big honkin' example that took me a minute to piece up.

+----------1----------+
| +--------O--------+ |
| | +------5------+ | |
| | | +----E----+ | | |
| | | | +-----+ | | | |
| | | | | +G+ | | | | |
C 3 D E - B O L L I 4 G
| | | | | +O+ | | | | |
| | | | +--W--+ | | | |
| | | +----F----+ | | |
| | +------6------+ | |
| +--------N--------+ |
+----------2----------+

And, amongst many other strings, for w=CODE-GOLFING|CODE-BOWLING you should return true.

---

This is ascii-artpermutationscode-golfparsing, if you're on my front lawn the third Tuesday of next month in a batman costume doing unspeakable things to my sprinkler system, you've won.

Answer 5

Home on the Range code-golf number

Challenge

Given a range [0,n) that has been shuffled, return the index of each element of the range.

Examples

[1, 2, 0] -> [2, 0, 1]

This is the range [0, 3) after being shuffled. The element at index 0 in the result is 2 because, in the input, 0 is at index 2. Likewise, the 0 in the output is the index of the 1 in the input, and the 1 is the index of 2.

[1, 0, 2] -> [1, 0, 2]
[0, 1, 2, 3] -> [0, 1, 2, 3]
[0, 2, 1, 3] -> [0, 2, 1, 3]
[2, 0, 1, 3] -> [1, 2, 0, 3]
[3, 2, 0, 1] -> [2, 3, 1, 0]
[4, 3, 2, 0, 1] -> [3, 4, 2, 1, 0]
[1, 2, 4, 0, 3] -> [3, 0, 1, 4, 2]
[2, 4, 0, 3, 1] -> [2, 4, 0, 3, 1]

Bonus

I will award a +100 bounty to the first person to design and explain an algorithm that solves this problem using O(n) time and O(1) space.

Sandbox

• I think my explanation was rather poor. How can I make this more clear?
• Is this a dupe?
• Is the bonus a good idea? (I really want to hear the answer because I don't know if this is even possible!)

Answer 6

Find the maximum number of coprimes in a set

Inspired by a recent question on Math.stackexchange.com, which I can't find anymore.

The challenge

Exactly what it says on the tin. You are given a set of integers and you have to create a program (according to the default definitions on meta) that outputs the size of the biggest subset that shares no divisors except for 1.

Input

A set of nonzero positive integers of length >= 2. You can take this input as per the defaults in meta.

Output

Output, print or return the size of the subset of the input that does not share any divisors except for one.

Testcases

1 2 3 4 5 6 7 8 9 10 11 12 13 14
7

1 3
1

2 3 5 7 9
4

2 3 5 7 11 13
6

Answer 7

Golf a program whose behavior is independent from Peano arithmetic

Your task is to write a program that doesn't take any input, and whose termination cannot be proved or disproved inside Peano arithmetic. This is code-golf, so the shortest byte count wins!

Rules

• Standard loopholes apply
• Shortest by count wins
• You can assume that your program runs in a machine with an unlimited amount of memory.

Tags

code-golf busy-beaver

---

Questions for meta

• Is this a good challenge?
• Is it a duplicate?
• I think the same question with a behavior independent of ZF set theory might be interesting as well (see this link for instance), but will attract very different answers; should I post it as a separate challenge?
• What can be improved? Are the tags ok?

Answer 8

Iterate over all sets

(This question needs fixing so that the output size is not too large)

Consider all possible pairs of sets of integers (can have positive, negative and zero values) A and B such that |A| = |B| = 7. Define the set T_{A,B} = {a * b | a in A, B in B}.

The challenge is to iterate over all pairs of sets A and B so that |T_{A,B}| < 19 and the largest absolute value of an integer in A or B is at most 128. As an example of one such pair of sets, A = B = {2^i | for i in {1,...,7}}.

What should my code output?

Your code should output the pairs of sets A, B along with |T_{A,B}|.

For example:

A = {2,4,8,16,32,64,128}, B = {2,4,8,16,32,64,128}, |T_{A,B}| = 13.

Running time

I don't care how long your code takes to run except you must run your answer to completion before posting an answer.

Answer 9

Code golf the Fast growing hierarchy (fgh)

if your not familiar with the fgh you migth want to check out this explantion: Large Numbers, Part 3: Functions and Ordinals

and these value aproximations: Fast growing hierarchy Approximations

the goal this code golf is to golf the following functions:

• the exact value of f_ω(x) this means you can't golf the ackermann function

• the growth rate of f_ω2(x)

• the growth rate of f_ω²(x)

In any language of your chose.

This is a code golf so the smallest program that defines each of these functions wins (Note:the functions are allowed to call each other).

It is also allowed to ask for an input x and output the 3 function values in any order.

Tags

busy-beaver,growth-rate-golf,code-golf,recursion

Sandbox notes

I'm not sure on which functions should be the target but these functions seem challenging yet golf-able in less than 150 bytes.

Upon closer inspection I realized that f_ω²(x) is probably to easy since it can be golfed with something like:

f(x,a...) {
    for i in range(a.length) {
        if(a[i] != 0) { //first non zero
            Arrays.fill(a, 0, i, x); //replace 0's with x
            a[i]--; //decrement a[i]
            return f^x(x,a);
        }
    }
    //all zeros
    return x+1;
}

f(x,n) > f_n(x)

f(x,0,n) > f_ωn(x)

f(x,0,0,n) > f_ω^n(x)

so f(x,0,...,0,x) (x zeros) ~= f_ε0(x)

Any other tags? Suggestions? Does this interest you?

Answer 10

Just One More Time code-golf

Challenge

Write a program or function that will run without error once, but will crash when run for the second time.

If you are writing a function, you may assume the function will be run twice within the same interpreter session or program.

If you are writing a program, you may assume the machine will not be rebooted between runs.

Scoring

This is code-golf, so the shortest answer in each language wins.

Answer 11

What Tiles did I have?

Everyone should be aware of the scoring system in a classic board game: Scrabble. I remember going back into my old scrabble box and finding some old post-it notes containing old scores. I always wonder what the heck was played for some of the more insane point scores. That gave me the idea for this challenge...

---

English-language editions of Scrabble contain 100 letter tiles, in the following distribution:

• 0 points: * x 2 (These are the blank tiles)
• 1 point: E ×12, A ×9, I ×9, O ×8, N ×6, R ×6, T ×6, L ×4, S ×4, U ×4
• 2 points: D ×4, G ×3
• 3 points: B ×2, C ×2, M ×2, P ×2
• 4 points: F ×2, H ×2, V ×2, W ×2, Y ×2
• 5 points: K ×1
• 8 points: J ×1, X ×1
• 10 points: Q ×1, Z ×1

---

Your challenge is, given a single integer input between 0 and 185, output a corresponding sequence of scrabble tiles that sum to that score with a length between 2 and 100 characters in length.

The Specifics

• The letters don't have to spell anything, they just have to sum to that score.
• You can only use a tile the number of times it exists (E.G. E can be used 12 times).
• The shortest word is 2 characters long, for an input of 0 you get **.
• Outputs will not match between answers, as there are many solutions.

Inputs and Outputs

• Input should be a single integer, anything else is wrong.
• Output should be a single string, with no spaces, order of letters is arbitrary.

Example (Potential Solution)

0   | **
1   | *E
2   | EE
[... Pattern Omitted ...]
12  | EEEEEEEEEEE
13  | EEEEEEEEEEEA
[... Pattern Omitted ...]
68  | EEEEEEEEEEEEAAAAAAAAAIIIIIIIIIOOOOOOOONNNNNNRRRRRRRTTTTTTLLLLSSSSUUUU
[... Arbitrary Ordering Omitted ...]
185 | EEEEEEEEEEEEAAAAAAAAAIIIIIIIIIOOOOOOOONNNNNNRRRRRRRTTTTTTLLLLSSSSUUUUDDDDGGGBBCCMMPPFFHHVVWWYYKJXZQ

---

This is code-golf,strings: Whomever contacts Cthulhu using the dark arts first wins.

Answer 12

Display the Undisplayable

I have sometimes seen answers to challenges, written in binary machine code. The users who post them usually display them in hexadecimal representation. This representation makes the code extremely long, and does not do them justice!

Thus, we should give them help, and I don't care if they don't need it. Your task will to write a program/function/eldritch incantation to turn their beautifully golfed binary code into the shortest possible string of printable characters.

Input

A sequence of random binary data of random length. Use any of the standard IO methods (note to self: find the link to the Meta post).

Output

A sequence of printable characters. Use any of the standard IO methods.

• If encoding is relevant, you are free to choose any encoding, provided you clearly indicate which one you used in your answer. What is relevant is the number of characters anyway.

• Whitespaces (regular space, new line, non-breaking space, form feed, etc.) are considered not printable. They can be added if you wish, but their presence or absence must not impact the decoding of the output.

Conditions

• There must exist a program, that can take any possible output of your program, and turn it back into the input (providing it is not needed, but will be smiley'd at).

• If your program is run twice, with 2 inputs of same size, the 2 resulting outputs must have the same size.

• Standard loopholes apply.

Score

The score is calcaulated as the number of bytes in the input, divided by the number of characters in the output. The higher the better.

If the score varies depending on the length of the input, take its average over input sizes from 1 to 1024 bytes included (I don't think we'll have answer 1 kb long here).

---

Giving an answer in a binary language (machine code, LLVM bitcode, etc.) and adding the output when run with its own binary source will be smiley'd at (but no bonus, unless it can also summon Cthulhu).

Don't forget to explain how your code works!

---

Meta

• Do you think it's a good idea? Is there already a challenge like this one?
• Is there any blatant loophole/possible imporvements?
• What tag(s) do you recommend for this challenge? (please edit the answer)

Answer 13

Every Nth Line in Source Outputs N

code-challenge source-layout

Heavily inspired by Hello, World! (Every other character)

Related to my other Sandbox post Every Nth Char in Source Outputs N; is it a dupe?

Write a program that outputs 1. When the first, third, fifth, etc. lines are removed, it outputs 2. When all lines where their (1-based) index in the source, mod N, are not 0, are removed, it should output N.

This is code-challenge. The winner is the program that works with the largest N, while working for all n < N (obviously, to run up to N, it has to be at least N lines long). If there is a tie, the winner is the shortest answer that reaches the largest N. Your program must at least work up to N=2, since I don't think any languages will struggle with simply printing 1.

Example

Examples are based off of this sample program:

test
hi
world
hello
12345
System.out.println(test);
timeout
let's dance

For the program to work for N=1, the original program should output 1.

For the program to work for N=2, the following should output 2:

hi
hello
System.out.println(test);
let's dance

For the program to work for N=3, the following should output 3:

world
System.out.println(test);

For the program to work for N=4, the following should output 4:

hello
let's dance

For the program to work for N=5, the following should output 5:

12345

etc.

The highest N this program could work for is its line length, 8.

Answer 14

Sandboxing this mostly so I don't forget about it (as I don't want to initiate this so soon after v3). Unlikely to need any serious revision, but comments are appreciated none the less.

Prisoner's Dilemma v4: The Amnesiac Gentlemen.

This is similar to v3 Petri Dilemma, except with one significant change: no one knows what round it is. The same setup, submission format, and scoring will be used. For sandbox brevity, I'm only noting the differences from v3.

Bots will receive input at the beginning of its turn in the format:

current points, enemies points, your previous moves, enemy's previous moves

The format of the move list (both yours and the enemy's) will be a string of characters, "c" for cooperation "d" for defection, in order from first round to last. However this list will contain only the first seven moves of the game as well as the most recent 7 moves (as everyone knows, you can only hold seven items in working memory). A String 14 characters or fewer would indicate a round at the beginning of the game where 14 total moves haven't yet been performed. Later rounds would be indeterminate.

Additionally, as the current round number is not being passed in, bots will be unaware of when the end of the game comes (games will still be 200 rounds). This should prevent "Ah ha, last round, I backstab!" "Ah ha, but I backstab you first, one round earlier!" strategies, which is what dominated a large swath of the v3 strategic playspace (I did tests where all backstab-early bots were coded to all backstab on the same round and there were only two that performed sub-optimally as a result, both of which were set to backstab "before all n-Tit-for-Tat strategies", moving them back 1 rounds re-elevated them above n-Tit-for-Tat again, as well as which one backstabbed the other first determining the winner between them). While several bots from v3 would be valid submissions in v4, all of the winning bots utilize more data than v4 will let them have, opening up the playing field for new techniques.

Here are four sample strategies that will be entered to start with:

Tit for Tat

def titfortatfunc(mypoints, enpoints, mylist, enlist):
    if not enlist or enlist[counter-1] == "c":
        return "c"
    else:
        return "d"

RandomPick

from random import choice
def randompickfunc(mypoints, enpoints, mylist, enlist):
    return choice(["d", "c"])

Cooperator

def cooperatorfunc(mypoints, enpoints, mylist, enlist):
    return "c"

Defector

def defectorfunc(mypoints, enpoints, mylist, enlist):
    return "d"

Answer 15

(Code Golf) How Many Notes Are There?

Background

Most music games (MUG) describes the "instructions" that the player must follow as "notes". When the charts (set of notes) are first available, MUG players usually record the chart as a video and upload them to video sites. However, unless playing a full combo (able to pick up all notes) that the combo count directly shows the number of notes, it is usually not practical to count the number of notes one by one directly (since there are usually hundreds of notes), so they calculate that from the scores that may show on those videos if the score formula is known.

One of those examples is jubeat, which is somehow like a MUG version of "Whack-a-Mole". Although officially "instructions" are called "chips", players have the consensus to call them "notes". (For those who don't know what jubeat is please check it out here: jubeat - RemyWiki)

Objective

What you have to do, is to:

• Write a program or function,
• Which accepts a list of integers as the only input,
• That calculates the numbers of notes which is possible for all the given "basic scores".

Requirements

• The input can be an array of integers or a string containing those integers (Please indicate the input format).
• The integers in the input are guaranteed to be in the range of [0, 900000] inclusive.
• A case (NOTES in the formula) is possible means that, for each integer in the input, there exists a variable ACH, when substituted into the formula below, the formula evaluates to that integer. (See The Formula and Test Cases for details)
• All possible cases within the range [1, 1100] inclusive must be included in the output.
• The output can be an array of integers or a string containing the results (Please indicate the output format).
• If there is no case fulfilling the requirements, the program or function should either return an empty array, an empty string, null, or any objects indicating absence of results.
• NO RUNTIME EXCEPTIONS shall be thrown in any circumstances.

The Formula

The max score is 1000000, but here we only consider BASIC_SCORE, whose maximum is 900000.

The BASIC_SCORE is calculated by BASIC_SCORE = floor(floor(ACH * 100000 / NOTES) * 0.9), where ACH is an integer in the range [0, NOTES*10] inclusive except NOTES*10-1 and NOTES*10-2.

As a concrete example, take ACH=6850, NOTES=900, we have BASIC_SCORE = floor(floor(6850 * 100000 / 900) * 0.9) = 684999.

As a result, NOTES=900 is a possible case for the basic score 684999.

Test cases

 Input                                    | Output
-----------------------------------------------------------------------------------------
 896757, 846353, 844486                   | 916
 891000, 893999                           | (all multiples of 30 within [1, 1100])
 899736                                   | 1024, 1025, 1026, 1027
                                          | (342, 683, 684 are false positives because  
                                          |  in these cases ACH = NOTES*10-1 or 
                                          |  ACH = NOTES*10-2)
 873540, 802468                           | (none: no case fits all inputs.
                                          |  some cases do fit some inputs but not all)
 0, 900000                                | (all values within [1..1100])
 800000                                   | (none)

Rules and Winning Criteria

This is a code-golf, so the source code with the shortest length (in terms of bytes) wins. Standard loopholes apply.

Answer 16

Poor Man's Ransomware

This challenge is loosely inspired by the cheapo-enigma machine question. However, I beleive that the differences are substantial enough that this would not be a dupe. Feedback welcome.

---

You have been captured by a morally questionable "employer" and forced to write a piece of "ransomware". All it has to do is take in a string "in whatever format" and output another string (which can be used to recover the files) Essentially, across the set of all possible inputs (infinite) you will define a one to one function.

Participants will then publish their code to stack-exchange, where other aspiring "hackers" will try to break your code. A "cop" submission will consist of a byte count a sample plaintext and a sample "encrypted" file as well as an encrypted copy of your code.

Robbers will work tirelessly in another thread to reproduce your code. Any submission which correctly produces the corresponding "encrypted" files when fed the sample plaintext and itself will be considered to be cracked.

If your code lasts 7 days or longer you may mark your submission as "safe" by publishing the source code for the encryptor and a decryptor. Until this time robbers may still work to break your code. If anyone finds that a specific decryptor fails on a certain plaintext it is invalid.

The winning cop has the shortest safe submission and the winning robber has the largest sum of the bytes of his cracked cops. Ties go to the earlier poster. Good Luck!

Answer 17

Count bytes like a Java golfer

Java is verbose, everybody knows that. Sometimes, here on PPCG, it happens that a Java answer is shorter than 60 characters, but most of the time it's longer, way longer! And the Java golfers here often post improvement suggestions in comments.

Alas, the PPCG website is based on the stack software, which invisibly cuts <code> comments according to an obscure rule, which I shall name the "Java golfer's bane", making it impossible to get an accurate byte-count by copy-pasting.

The rule in question is the following:

• in a <code> tag, insert two invisible characters
  • the first time after 60 non-whitespace consecutive characters
  • then subsequently ever 20 non-whitespace consecutive characters

Challenge

Your goal is to help us, poor Java golfers, to get the byte-count straight from when we copy/paste code from comments.

SE software rules are, I'm sure, complex, so we will simplify a bit, but not that much.

• Your input:
  • is mappable to UTF-8;
  • must support codepoints until at least U+FFFF;
  • will contain only characters with codepoints greater than or equal to U+0020;
  • must be a string or a characters array/list if those accept unicode characters, or else must be an integer (16 bits minimum) array/list. Unless I forgot anything obvious, no other input format is allowed.
• If a sequence of non-whitespace characters in the input contains more than 60 characters:
  • keep the 60 first characters, then skip the next 2 characters;
  • then until you meet a whitespace, keep the next 20 characters and skip the next 2.
  • We don't care which are the two stripped characters.
• Your output is the size of the string after being sanitized, in bytes as encoded in UTF-8! You must support very long Java answers, up to 500 characters (not bytes).
  • You don't need to map to UTF-8 since I give the rule on how to count without mapping, but in some languages it might be easier to actually map!
• The standard loopholes are naturally forbidden.
• This is codegolf, so the shortest answer in bytes wins!

You may assume the following:

• the only whitespace character you will ever get is the space (U+0020). I abuse the term whitespace by including the start of the string as well in its meaning.
• no whitespace will be at positions 62, 94, 116, (+22) ... after the previous whitespace

You may not assume the following:

• The skippable characters will exclusively be the ones SE actually uses (U+200C U+200B);
• you will get only ASCII characters;
• you will not get any diacritics.

Bonus

• if your code supports Unicode code points up to U+1FFFFF, you can remove 10% off your byte count, do not round the resut.

How to count the number of UTF-8 bytes?

If you haven't a builtin for that, Wikipedia gives us the rule, based on code points:

first code point  |  last code point  |  # bytes
U+0000            |  U+007F           |  1
U+0080            |  U+07FF           |  2
U+0800            |  U+FFFF           |  3
U+10000           |  U+1FFFFF         |  4

Wikipedia goes beyond those number, but the RFC 3629 capped this mapping to 4 bytes, so we thank it!

Test cases

Work in progress!

---

Notes for review:

• Suggested tags: code-golf, string, unicode
• Related:
  • Bytes/Character (different as there is an additional string manipulation)

Answer 18

What feedback do you have for me?

Challenge

Convert and print out a time in a 12-hour format. HH:MM AM/PM

Examples

Input:

• 'Fri Jun 30 2017 21:14:20 GMT-0700 (PDT)'
• 'Sat Jun 31 2018 08:06:20 GMT-0700 (PDT)'
• 'Fri Jul 01 2017 01:14:20 GMT-0700 (PDT)'
• 'Sat Apr 10 2020 09:06:20 GMT-0700 (PDT)'

Ouput:

• 09:14 PM
• 08:06 AM
• 01:14 AM
• 09:06 AM

Rules

• This is code-golf so the shortest solution in bytes wins
• Standard Loopholes Apply
• You may use functions as well as programs

Answer 19

Help! My code has exploded! code-challenge

Insert backstory here

Task:

Your task is to create a program, which must follow these rules:

• It must be able to be split exactly into pieces of the same length in bytes.
• Once you have separated your program into pieces, your program must print 1 if the first "piece" is removed from your code, 2 if the second "piece" is removed, etc., until the program prints n if the nth piece is removed.

For example, if your program was the following:

aabbccdd

And it could be split into 4 equal parts of length 2, then these programs must result in the following outputs:

bbccdd -> 1 (aa is removed)
aaccdd -> 2 (bb is removed)
aabbdd -> 3 (cc is removed)
aabbcc -> 4 (dd is removed)

Scoring requirements:

Your program is scored based on the number of parts that it can be split into, with each part following the rules defined above. The more parts, the higher the score.

In the event of a tie, there is a "hierarchy" of scoring methods (with the next method in the list being used when there is a tie):

• Number of parts the program can be split equally into
• Size of the full program, in bytes (shortest byte-count wins)
• Time posted (first poster wins)

Rules:

• Each byte in the program must belong to one part.
• Each part in the program must be of equal length.

Answer 20

Introduction

Ten years ago, a secret encryption key used by DVD players was published online. When the industry tried to censor it, the internet reacted by republishing it widely—creatively incorporating the key onto shirts, a flag and even in song.

If this code golf community had existed, I'm sure we would have joined in.

Challenge

Output the number 13256278887989457651018865901401704640.

Example input and output

Input:

Not applicable.

Output:

13256278887989457651018865901401704640

Answer 21

Decode Reddit's Voting System code-golf number

Background

Users with a high enough reputation on Stack Exchange can see the number of upvotes and downvotes on each question and answer. On Reddit, however, the net vote count and percentage of upvotes are displayed. Unfortunately due to rounding errors, it is impossible to determine exactly how many upvotes and downvotes occurred.

Challenge

Given a nonzero net vote count and a percentage of upvotes, return all possible pairs of the numbers of upvotes and downvotes.

Constraints

The net vote count can be any integer in the range [-2^31, 2^31).

The percentage can be a whole number in the range [0, 100], or a floating point number in the range [0, 1] with no more than two digits; you may decide which format to accept.

The percentage represents the percentage of votes which are upvotes, rounded to the nearest integer. So a value of 93% could be anywhere in the range [92.5%, 93.5%) that would result

The maximum numbers of upvotes and downvotes will not fall outside the range [-2^31, 2^31); that is, you should be safe using 32-bit signed integers.

You may not return two ranges representing all possible amounts of downvotes and upvotes; you must specify which numbers of upvotes correspond to which numbers of downvotes; hence you must return all possible pairs.

Test Cases

1, 67%  -> [(2, 1)]
1, 100% -> [(1, 0)]
1, 60%  -> [(3, 2)]
0, 50%  -> [(0, 0), (1, 1), (2, 2), ...]; cases like this will not be valid input
More involved ones to come...

Meta

Anything I can do to make this more clear or more fun?

Answer 22

Create The Correct Path

Which would be better code golf with shortest code and being able to run on at least two operating systems or code challenge and scoring by how many operating systems it can run on?

(code-golf OR code-challenge) file-system

Given an input create a program that when ran on different operating systems creates a path for each one. For example, when ran on Windows:

[ "folder1", "folder2" ] -> folder1\folder2

Input

An array of strings or any suitable alternative. The input can be empty, in which case you would just return an empty string.

Output

The correct path for the operating system the program has been ran on.

Answer 23

If you've come here, you probably know what code-golf is, and that's what I'm going to assume.

Story

(I guess)

Keyboards are input devices we use all the time. They existed before mice and touch screen, etc.

Their fundamentals have not changed: when you press a key down, a signal is sent to the computer. When you release it, another signal is sent.

So here's the challenge: calculate the minimum number of signals(length of a signal does not matter) depending on the input string.

Example:

Input:

test

Output:

8

Explanation: All keys have to be pressed down and released

Input2:

TEst

Output2:

10

Explanation: Shift has to be pressed, then T, down, up, E, down, up, then release shift, then s down, up, then t down, up, totalling up to 10.

Rules

Any language is accepted.
This is code-golf, so shortest code in bytes wins.
Programs with incorrect outputs will be disqualified.

Happy golfing!

Edit:

The keyboard layout used should be this: http://dry.sailingissues.com/keyboard-US-International.png

Only characters in this keyboard layout will be used (+lowercase letters).

Using Caps-Lock is ok, since it DOES have an advantage: numbers remain numbers while letters become uppercase.

Thanks for the feedback so far.

Answer 24

Abbreviate a rename

After you commit a rename, git reminds you but tries to avoid showing the full source and target path. It does this by splitting the path into components, extracting identical leading and trailing components, then using them to abbreviate the rename. (Other output that git produces is not relevant here.) Here is an example:

foo/bar/baz/quux.c => foo/baz/bar/quux.c

The leading component foo and trailing component quux.c is the same, so this becomes

foo/{bar/baz => baz/bar}/quux.c

This also works when one of the components is empty, e.g.:

foo/{bar/baz => }/quux.c
foo/{ => baz/bar}/quux.c

Please write a program or function that abbreviates a rename. The input can be a pair of strings or a single string with a delimiter which can be => or newline or something else not typically found in a file name. The output should be a single string containing a => as shown. You can assume that neither string is a prefix of the other (git doesn't abbreviate the rename in that case for some reason.)

This is code-golf, so the shortest program wins!

Answer 25

Lazy programmers need help versioning!

code-golf string

So here's a question, which is related to a recent problem I had while doing some data processing. I think it is good practice to include version numbers in file names to prevent data being overwritten and so you can see how things have changed with each version but I'm lazy so want it automating!

Your challenge

Take a full Windows file path and either increment the file version, or if there is no version, make it version 1.

Input

A full Windows file path, that includes the file extension.

Output

The original file path with the file version, incremented appropriately.

Rules

• The version is determined by an underscore followed by a single digit, i.e _1 for version 1.
• For a file that already have a version, it will only be in the range 1-8, so you only ever have to deal with single digit file versions.
• Standard rules apply
• Default Loopholes are forbidden.
• Please provide explanations of your code so others can learn form it and if possible, links to an online interpreter such as TIO
• This is code-golf so shortest code in bytes wins!

Test cases

Case 1
Input:  C:\Foo\Bar.txt
Output: C:\Foo\Bar_1.txt

Case 2
Input:  C:\notsortedfile_version_1_new_5.docx
Output: C:\notsortedfile_version_1_new_6.docx

Case 3
Input:  D:\a\very\deep\file\567234.pdf
Output: D:\a\very\deep\file\567234_1.pdf

Case 4
Input:  Z:\Storage\Somefile_2017-04-11.txt
Output: Z:\Storage\Somefile_2017-04-11_1.txt

Case 5
Input:  Z:\Storage\I.Like.Dots.txt
Output: Z:\Storage\I.Like.Dots_1.txt

Sandbox Questions

Not sure if this is dupe of Please release me!

Any feedback welcome.

Answer 26

Let's simplify polynomials

In many situations we have to expand mathematical expressions containing variables, for example, calculating characteristic polynomials, expanding products of polynomials, etc. It is trivial if the variables are known (in this case, we just substitute the variables with the corresponding values and evaluate the expression by a calculator), but not so simple if we need to manually expand the expression.

Motivation

Consider the cases with only one variable (say, x). Suppose the coefficients are sufficiently small. Then, a simple way is to take x to be some number (e.g. 1000), evaluate the expression and convert the numerical answer back to a polynomial.

Here is an example. Suppose we need to expand

Put and evaluate it using a dumb calculator. The answer is .

By running the program/function with input -984982000, one should get

[-1, 15, 18, 0] (descending order)

, and so the expanded polynomial is .

The task

Write a program or function which satisfies the following:

• The input is an integer, which is calculated by substituting x = 1000 in a polynomial (which you have to find out).
• Output the coefficients, guaranteed to be in the range [-499,499] (inclusive), and to be integers. You can represent the polynomial in either ascending or descending order, so long as it is consistent across different runs. You can return a list of integers, print to standard output (with non-numeric separators), etc.

Examples

Input         Output (descending power)
1003005007    1 3 5 7
1001          1 1
999           1 -1
998994        1 -1 -6
-998994       -1 1 6
1000001       1 0 1
0             0


Input
1003005007

Valid outputs                     Invalid outputs
[1 3 5 7] (descending order)      1357 (coefficients are not separated)
[7 5 3 1] (ascending order)       7531 (coefficients are not separated)
"1 3 5 7" (descending order)      "1357" (coefficients are not separated)
"7, 5, 3, 1" (ascending order)    [1 5 3 7] (neither ascending nor descending order)
7                                 "10305070" (numeric separator "0")
5
3
1 (ascending order)

Rules

1. Standard loophole applies.
2. Your program/function should be able to at least handle polynomials of degree 3. Also, the input might be negative. Therefore, using a suitable data type is necessary.
3. You can take the input in integer or string format. It is guaranteed that the input is a valid integer.
4. The shortest program/function (in bytes) wins. Good luck!

Answer 27

Fighting a Land War

In this KoTH, you need to earn as much money as you can while fighting over tiles to take over.

The board is a large hexagon made up of 91 smaller hexagonal tiles (A 6x6 hexagon)

Each tile is either:

1. An impassable mountain
2. Hills that generate production. They start out with a random value (between 2 to 4)
3. Valleys that generate money. Their starting value is the distance from the nearest corner multiplied by 2 (between 2 and 10)

There are 6 players in each game, each starting in a different corner of the hexagon. The corner will always be a hill(4). Turn order is randomized at the start of the game.

Each turn, the following happens:

1. Each tile that you have owned for N^2 turns (where N is an integer) increases in value by 1
2. You earn money/production. (Equal to the sum of the valley/hill values)
3. You can spend production on defenses or capturing tiles.
   • Adding N TileDefense costs N Production
   • Capturing a tile with N TileDefense costs 1 + 2*N Production
   • You can only capture a tile if it is a non-mountain tile that is adjacent to your current tiles.

Notes:

• Tiles lose all defense on capture.
• Multiple players can upgrade a single tile
  • The turn counter for tile upgrades is player-specific. This means that if you capture a tile from another player, the turn counter starts at 0.
  • If you capture a tile you've owned before, it starts off where you left it.

And that's it. The player with the most money after 500? turns wins.

Answer 28

What's Underneath the Sine Wave?

kolmogorov-complexity code-golf

Task

Your task is to output a part of the sine wave out of any characterss of your choosing and on any background of your choosing. The wave can start and end either on the highest or the lowest point of the wave if both are the same.

The challenges main part is what happens below the wave (or above if you chose to start at the peaks of the wave). For each column, looking top-to-down it should repeat until the bottom the segment of spaces until the wave.

Or a visual explanation:

Start with a sine wave of your choosing (this is not a valid one as it isn't 50x20, but smaller to save space):

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

and then, look top-down and until the 1st encounter of a non-background character record the characters and then repeat them:

        ↓   ↓####             
        ↓  ##  P ##           
      4x↓ # ↓  P   #          
        ↓#  P  P    #         
        X   ↓  P     #        
       #↓   P  P      #       
      # ↓4x ↓  P       #      
     #  ↓   P  P        #     
    #   ↓   ↓  P         #    
  ##    P   P  P          ##  
##      ↓   ↓  P            ##

so for this the output would be

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

Clarifications

• There can be any amount of leading/trailing lines with any amount of whitespace
• On each line there can be extra leading whitespace, as long as the amount is equal on all lines
• The width should be at least 50 characters total (excluding columns of only whitespace)
• The height should be at least 20 characters total (excluding lines of whitespace only)
• The repeating bottom parts must be cut from the bottom (or top) of the wave
• Inaccuracies due to rounding or floating-point errors can be dismissed
• The background character has to be constant
• The wave characters can be different, as long as they aren't ever equal to the background
• This is code-golf, the shortest code per language wins!

Sample outputs

                         XXXXXX
                       XXXXXXXXXX
                     XX  XXXXXX  XX
                    X  XXXXXXXXXX  X
                   X     XXXXXX     X
                  X  XXXXXXXXXXXXXX  X
                XX       XXXXXX       XX
               X    X  XXXXXXXXXX  X    X
              X      XX  XXXXXX  XX      X
             X     X   XXXXXXXXXX   X     X
            X            XXXXXX            X
           X      X XXXXXXXXXXXXXXXX X      X
          X              XXXXXX              X
         X      XX     XXXXXXXXXX     XX      X
        X          X XX  XXXXXX  XX X          X
       X       X    X  XXXXXXXXXX  X    X       X
      X                  XXXXXX                  X
    XX        X   X  XXXXXXXXXXXXXX  X   X        XX
   X                     XXXXXX                     X
XXX          X     XX  XXXXXXXXXX  XX     X          XXX

..................................................
DCB....................QPONM....................10
...A9........0.......SRQPONMLK.......C........32
.....8..........X...T..QPONM..J...F..........4
......7.......Z...VU.SRQPONMLK.IH...D.......5
.......6...............QPONM...............6
........5......Y.W..TSRQPONMLKJ..G.E......7
.........4.............QPONM.............8
...................U.SRQPONMLK.I
..........3.......V.T..QPONM..J.H.......9
...........2....X....SRQPONMLK....F....A
............1..........QPONM..........B
.................W.UTSRQPONMLKJI.G
.............0.........QPONM.........C
..............Z...V..SRQPONMLK..H...D
...............Y....T..QPONM..J....E
...................U.SRQPONMLK.I
................X......QPONM......F
.................W..TSRQPONMLKJ..G
..................V....QPONM....H
...................U.SRQPONMLK.I
....................T..QPONM..J
.....................SRQPONMLK
.......................QPONM..................................
...
.
....

sandbox

• please suggest (or just edit in) ways of making this clearer
• Anything missing?
• Should I make this challenge take input, rather than being an broad kolmogorov-complexity challenge?

Answer 29

Pristine Pristige

A pristine program, as defined by Calvin'sHobbies, is

a program that does not have any errors itself but will error if you modify it by removing any contiguous substring of N characters, where 0 < N < program length.

Pristige is a language I designed in which all syntactically valid programs are pristine.

Pristige works just like Brain-Flak, except every function requires a airity declaration at the beginning. An airity of n is declared with n .s followed by a |. For example the Brain-Flak program

({}())

Is equivalent to the Pristige Program

(..|{|}(|))

In addition Pristige requires that there is only one function at the top level of the program. Meaning that

(.|{|}){.|(..|{|}[.|(|)])}

Is an invalid program.

To be absolutely concrete here is a grammar that spans all syntactically valid Pristige programs:

S → (A) : <A> : {A} : [A]
A → .AS : |

Task

You must write a compiler from Pristige to Brain-Flak, that is itself a pristine program.

This is a code-golf question so answers will be scored in bytes, with less bytes being better.

Rules

• You must either throw an error (or print error if your language cannot do so) if the inputted program is syntactically invalid.

• If the input is syntactically valid you must output an equivalent Brain-Flak program. The simplest way to do this is to remove all instances of . and |, but you are not required to do so.

• You may use any default IO format.

• Your program must be a pristine program. That means deleting any continuous substring must cause an error

Reference Implementation

Here will go an implementation I have not yet completed

Test Cases

Here will go test cases

Answer 30

Write a code poem programming-puzzle popularity-contest

It is said that Larry Wall, creator of Perl, wrote a poem titled "Black Perl" in said language, as shown here.

The poem is fully functional (working syntax, no runtime errors, etc. [no errors in general]).

The challenge:

In any language (practical languages recommended), write a haiku (example of one at https://en.wikipedia.org/wiki/Haiku).

Coding rules:

• The poem must be able to function properly (no errors).
• Unlike Wall's poem, you must run through the whole program (exits only at the end).
• If you define a function to act as a word, it will count towards your poem.
• Caught errors and other error-handling tricks are valid.

Misc rules:

• You cannot use multi-line strings or line continue symbols, etc. (No multi-line functions/tricks).
• Brackets, parentheses, and other grouping symbols (with the exception of < and > as operators are ignored unless as a string.

Example lines (written in Python, not the best, probably):

while i_love ....: # i_love counts as two words

i_am > than_you # read symbols/operators as words

"""my love for ...
is ....... by ...""" # Invalid, as stated by one of the misc. rules

me(,"john", "abby",
    "and liz") # invalid, line continuation

Winning:

This is a popularity-contest, so submission with the highest amount of votes wins.

For sandbox only:

How can I improve on this challenge? Is there anything else I should add? Let me know in the comments.