485
\$\begingroup\$

What is the Sandbox?

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

To post to the Sandbox, scroll to the bottom of this page or click on the "Add Proposal" link below, and click "Answer This Question". Click "OK" when it asks if you really want to add another answer. Write your challenge just as you would when actually posting it. You may also add some notes about specific things you would like to clarify before posting it. Other users will help you improve your challenge by rating and discussing it. When you think your challenge is ready for the public, go ahead and post it, replace the post here with a link to the challenge and delete it.

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

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

Add Proposal

Search the Sandbox

Browse your pending proposals

Get the Sandbox Viewer to view the sandbox more easily

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

| |
\$\endgroup\$

2925 Answers 2925

1
85 86
87
88 89
98
0
\$\begingroup\$

The game of scrabble is played by placing lettered tiles on a grid to form words. The words being formed must read from left to right, or up to down on the grid. The words must appear in the official Scrabble dictionary, and all letters placed on the grid must be part of a valid word. This challenge will focus on a specific technique for playing a simplified version of Scrabble.

A useful technique when playing Scrabble is to add a single letter to an existing word that is already on the board to form a new word. Write a program or function that, when given a dictionary, finds the longest series of words that can be formed by adding a single letter to another word to form a new word.

Example

You are given the following dictionary:

at
ate
rate
elate
crate
belate
belated

Your submission should output:

['at', 'ate', 'rate', 'crate']

An invalid output would be:

['at', 'ate', 'elate', 'belate', 'belated']

because 'elate' cannot be formed by adding a single letter to 'ate'.

Note that this challenge is not about finding the longest word that can be formed by adding a single letter to another word, but about finding the longest chain of words that can be formed in such a way. Which means that this answer:

['elate', 'belate', 'belated']

is wrong, because it only has three steps, whereas the first example has four.

Winning Criteria

Code-golf, so shortest code wins. I/O is flexible. Standard loopholes apply. Take dictionary as a list, file, delimited string, or whatever you want. Output can be sent to stdout, returned as a single string (with delimiter), or list of strings.

Test Cases

TODO

| |
\$\endgroup\$
0
\$\begingroup\$

Uniform necklace sampling

The challenge is, given a number \$N\$, to produce a random binary necklace of length \$N\$. All possible necklaces must have the same probability of being chosen.

[TODO: more about necklaces]

Scoring

Solutions are compared first by asymptotic memory complexity in \$N\$ (lower is better), and, in case of a tie, by size (lower is better).

Sandbox stuff

(I do intend to use code-golf as only a tiebreaker)

  • How to tag this question the most correctly?
| |
\$\endgroup\$
  • \$\begingroup\$ Not time complexity? It's trivial to do this in O(n) memory (I think that is optimal, because (as far as I know) it's not possible to (deterministically) check if a string is a necklace in less memory) by iterating over all necklaces, count number of those = C (C can be represented in N bits), generate a random number x in the range 1..C, then count again and pick the xth necklace. \$\endgroup\$ – user202729 May 27 at 4:10
  • \$\begingroup\$ @user202729 I tried to pick a combinatorial object that prevents a linear-memory solution (any suggestions?). I guess these answers should win (with [code-golf] used to compare them - this is mostly [restricted-memory] code-golf, but submissions that aren't good enough aren't disqualified). \$\endgroup\$ – my pronoun is monicareinstate May 27 at 6:44
0
\$\begingroup\$

Posted: SELECT ALL FROM SelectQL WHERE (answer="short" OR NOT length=10000)

| |
\$\endgroup\$
  • \$\begingroup\$ What happens if the specified table doesn't exist? \$\endgroup\$ – Lyxal May 15 at 4:37
  • \$\begingroup\$ The usual SQL statement is SELECT * FROM data, where * is the wildcard operator. Also, the set of parentheses after "WHERE" is not mandatory in usual SQL. I guess these changes make the challenge easier to parse. \$\endgroup\$ – user92069 May 15 at 4:56
  • \$\begingroup\$ @Λ̸̸ Yeah, it's to make it slightly easier. However, I could change it. Which I will! \$\endgroup\$ – bigyihsuan May 15 at 23:54
  • \$\begingroup\$ @Lyxal undefined, the programs should assume that the table is in the database \$\endgroup\$ – bigyihsuan May 15 at 23:55
  • 3
    \$\begingroup\$ Consider deleting this post, as the challenge is already on main \$\endgroup\$ – RGS May 20 at 16:50
0
\$\begingroup\$

Solve some diplomatic issues

You are given a set of moves in a theoretical Diplomacy game. We're not going to handle validation of moves being legal or not, simply attempt to resolve a turn.

Here are the simplified rules to Diplomacy (full rules here):

  • There are two types of units: Armies and Fleets. Armies can only move on land, Fleets on land and in the sea. You can safely ignore this, because we're assuming that all of the moves you've been given are at least theoretically valid.
  • There are four types of moves: Hold (stay in place), Move, Support (a certain other unit), Convoy.
  • When two or more units end up in the same country, whichever unit has the most support stays. Each unit without the most support (or each unit tied for the most) returns to its original country. A unit which is not Moving and which is not tied for the most support is Dislodged.
  • A Fleet can Convoy an Army through its space to another space. That convoy is cancelled if the Fleet is Dislodged. Only a Fleet in a sea space can Convoy.
  • A unit can support another unit holding or moving into an adjacent country if it can move into that country (Armies can't Support Fleets in the sea).
  • A supporting unit which is attacked ceases to support, unless it is supporting an attack on the unit attacking it. If it is dislodged, it ceases to support in any case.
  • The Beleaguered Garrison rule: If a unit is attacked by two units with the same amount of support, the attacked unit is not Dislodged, and the attackers return to their original countries.

You will receive a list of moves. Each move will be in the following format:

Power Unit_type Origin_country Move_type Destination_country

There is no Destination_country if a unit holds (or you can insert a placeholder). Destination_country for Support or Convoy is the Origin_country of the unit being Supported or Convoyed. For example, you could get:

E F Eng M Pic
F A Pic H
G A Bel S Eng

This means:

English Fleet in the English Channel Moves to Picardy
French Army in Picardy Holds
German Army in Belgium Supports the Fleet in the English Channel to Move to Picardy

Your output should be the location of each unit after the move. Any Dislodged unit should be marked as such.

Output format:

Power Unit_type Country Dislodged?

For the example given above, the output should be:

E F Pic
F A Pic D
G A Bel

The more difficult part of this is in regards to convoys. A convoy fails if there is no valid path for the army to take. For instance, if we have:

E F Nth C Den
E A Den M Hol
F F Eng M Nth
F F Bel S Eng

The French fleets dislodge the English Fleet in the North Sea, and the convoy does not take place. But if we also had

E F Hel C Den

There would still be a valid path for the English Army and the convoy would succeed.

Paradoxes

Be warned, there are paradoxes in Diplomacy. These are to be treated as undefined behaviour; any output is acceptable where

  1. Each unit is listed
  2. There is only one non-dislodged unit per country
  3. In any country with a dislodged unit there is a non-dislodged unit
  4. Each non-moving unit is listed in its origin country
  5. Each moving unit is listed either in its origin country or its destination country

Note that, in particular, each unit being in its starting country is a valid output.

Adjacency list

For use with convoys, it's helpful to know which countries are adjacent to which other countries. (Everything is assumed to be valid, but it may not be clear whether a convoy with a single cut link is still possible otherwise).

You may assume that this list is available to you in any format: a function that takes two countries and returns true/false, a variable, a file, etc. In any case, the list itself does not add to your byte count.

[To be added]

Input/Output Formats

You can use any Input/Output formats you choose, as is standard.

Questions for the sandbox

  • How much clearer does my description of the rules of Diplomacy need to be?
  • Does this sound like an interesting challenge?

| |
\$\endgroup\$
0
\$\begingroup\$

Enforce Social Distancing!

Related to Maintain Social Distancing!.

As in that challenge, there is a 2-dimensional array of 1s and 0s representing people. In it, social distancing is maintained if and only if all 1s are at least 6 squares apart, where distance metric used is \$|\Delta x| + |\Delta y|\$ (rectilinear or Manhattan).

The challenge here is to move some people in a given 2D array so that social distancing is maintained. It's guaranteed that it's possible to do so. Your program's score on a given input is the total distance moved by all people.

Your program's running time must not exceed 10 seconds on any of the test cases.

This is tagged , so there is a large set of inputs your programs will be tested on [TODO: actually create it]. The program with the lowest total score on all of these inputs wins.

Sandbox stuff

  • Is this currently a bad idea for the reasons specified by Shaggy in the following comment?

    I am sorry but I have downvoted this for what others may perceive to be a trivial reason: Code Golf is one of the few things I have left where I can escape how fucked my world has become; I absolutely do not want to come here to be reminded that I can't hug my family and friends.

  • Is there an optimal algorithm? (I hope not)
| |
\$\endgroup\$
0
\$\begingroup\$

Shorten the numbers

These numbers are taking up far too many bytes on my computer. Create a function/program to shorten any number using only Alphanumeric characters as the output.

Scoring

Scoring is based on optimized-output. Shortest number of characters produced for the following randomly generated numbers (plus one special number with repetition) wins. Add the number of output characters output for the 5 test numbers together for total score.

  • 94949267912781
  • 75477115147709
  • 79547324913976
  • 12345678998765
  • 11111122222222

The score of the non-optimized numbers = 70. (14 * 5)

Sandbox questions

  • does scoring make sense?
  • should I include a sample script, output, or both?
  • should I be more clear the answers should work on any number? (ie. "replacing each test number with one character is disallowed")?
| |
\$\endgroup\$
  • 2
    \$\begingroup\$ Base conversion from base 10 to base-255? \$\endgroup\$ – user92069 May 23 at 8:29
  • 2
    \$\begingroup\$ As long as you're scoring on those five test numbers, the winning score is going to be the absolute smallest thing you haven't explicitly forbidden. Not allowing solutions to be tailored to those five is what we'd call a non-observable requirement, and considering how many different ways it could be approached I'm not sure how well a human could even really try to judge it. On the other hand, if you try to score it over the natural numbers, we just do base conversion. I feel like this can't work as an output optimization challenge. \$\endgroup\$ – Unrelated String May 23 at 10:07
0
\$\begingroup\$

Posted.

| |
\$\endgroup\$
  • \$\begingroup\$ Are the prompts mandatory, should they be in that format? (or maybe all the input should be on one line like ?> [line]:[content] \$\endgroup\$ – Wezl May 21 at 18:49
  • \$\begingroup\$ This seems like an interesting challenge, but I think some details are missing. For starters, you should provide a full list of commands that our program must support, as well as a few more examples \$\endgroup\$ – math junkie May 21 at 18:56
  • \$\begingroup\$ @mathjunkie What do you think now? \$\endgroup\$ – nope May 21 at 22:30
  • \$\begingroup\$ Looks better. However, Bonuses in Code Golf is high on the list of "Things to avoid when writing challenges". I would recommend either including those bonus tasks as part of the main challenge or removing them completely \$\endgroup\$ – math junkie May 21 at 22:36
  • \$\begingroup\$ Ahh, good ol' edlin. \$\endgroup\$ – user92069 May 22 at 8:29
0
\$\begingroup\$

Match the entire lyrics of All-Star

The challenge is simple: create a program/function that, when given a string consisting of the entire lyrics to All-Star as they appear in this paste (or not), output whether or not they are, in fact, the entire lyrics. The given string may be off by one of two characters, or something completely different, like Moby Dick (approximately). Output may consist of any of two values that map to true and false. They could be 0 and 1, or t and f, or whatever you like so long as there are two distinct values. You can choose to print the output or return it (if you are a program or a function). This is , so shortest answer in bytes wins!

| |
\$\endgroup\$
  • 2
    \$\begingroup\$ If the input string can be anything, is there anything one could do other than to compress the correct text and compare to it? If so, that would just be a generic compression challenge. One could check some cryptographic hash of the input, but there will exist collisions even if they are not practical to find. \$\endgroup\$ – xnor May 24 at 3:44
0
\$\begingroup\$

Golf me a Bookmarklet Quine

Given a javascript program (or any utf-8 text) of arbitrary length, output it in my simplified version of URI form, like a bookmarklet. You can use https://mrcoles.com/bookmarklet/ as reference. Output should be in the form

javascript:[input with percent-encoding for special characters]

Special characters are any character that is not

  • Alphabetic (upper or lower)
  • a digit
  • the characters .,-,_, or ~ (period, hyphen, underscore, tilde)

Your program "should convert all other characters to bytes according to UTF-8, and then percent-encode those values"w

A percent-encoding mechanism is used to represent a data octet in a component when that octet's corresponding character is outside the allowed set or is being used as a delimiter of, or within, the component. A percent-encoded octet is encoded as a character triplet, consisting of the percent character "%" followed by the two hexadecimal digits representing that octet's numeric value. For example, "%20" is the percent-encoding for the binary octet "00100000" (ABNF: %x20), which in US-ASCII corresponds to the space character (SP). source

Lowercase hex is okay, but uppercase is preferred.

This is code golf, standard loopholes are prohibited, programs should handle input up to 20 lines and output in a single line.

The Twist (so it's not a duplicate)

If run with no input or just a newline (your choice), the program should output itself in the same format as if the program's source was inputted normally.

Examples

In                                              Out

[blank]                                         javascript:[the%20program%27s%20source]
g/re/p                                          javascript:g%2Fre%2Fp
https://www.youtube.com/watch?v=dQw4w9WgXcQ     javascript:https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DdQw4w9WgXcQ
alert("test!")                                  javascript:%7Balert(%22test!%22)


sandbox questions

  • What should I add?
  • What tags does this need?
  • Are my examples inconsistent?
  • What parts of the challenge are redundant?
| |
\$\endgroup\$
0
\$\begingroup\$

Comment: might be too similar to previous mutual quine challenge?

Collaboration/quasi-quine challenge

Write a valid submission (A) which prints the code for another competitor's valid submission (B). The languages used in A and B must be different.

Clarifying rules

If B prints the code for a third submission, C, it is not required that A and C be different languages. Similarly, the authors of A and B must be different, but A and C need not be. (More different languages/authors score higher, however.)

The shortest chain is for A to print B and B to print A.

Note that if A prints B, and B prints C, but C is not valid for some reason, then neither A nor B are valid either.

It is acknowledged that the validity of your submission may change over time, due to factors beyond your control. Try not to let this worry you too much. :)

Input

None

Output

Just the code described above. Nothing extraneous.

Scoring

Scoring is (A + L) * 100 + C where:

  • A is the number of distinct authors that directly or indirect print your solution. So if you are Q, and Z=>X=>Q=>X, your "A" is 2. (Each submission only has one author, the "answerer".)
  • L is the number of distinct languages in your quine circle, along the same lines as for authors. (Each submission only has one language. "Distinct" means really different, not just different versions or implementations of the same languages.)
  • C is the length of your solution in bytes.

(So, for a given circle of quines, all the submissions will have similar scores, with the length of the submission as tie-break.)

Standard loopholes are forbidden.

| |
\$\endgroup\$
  • \$\begingroup\$ I like it when your score improves if you use more languages. Any reason why you didn't include that? \$\endgroup\$ – Wezl Apr 30 at 21:51
  • \$\begingroup\$ Oh, what would an example of that be? I did consider something like having your score improve, the longer the chain is. Like, your score is the sum of the length of all the submissions divideded by the square of the number of participants or something. \$\endgroup\$ – Steve Bennett May 1 at 2:09
  • \$\begingroup\$ That would be nice, but I wouldn't know how to balance it well. Just a thought. \$\endgroup\$ – Wezl May 1 at 17:46
  • 2
    \$\begingroup\$ This seems to me like a chicken-and-egg situation. How could the first posted answer be valid if there are no B answers to print the code for? \$\endgroup\$ – math junkie May 25 at 15:35
  • 1
    \$\begingroup\$ This is another similar challenge. It had several problems that I think might occur again with your current setup. I'd recommend giving the criticism and answers there a read over. \$\endgroup\$ – FryAmTheEggman May 25 at 20:45
  • \$\begingroup\$ @mathjunkie It wouldn't. I don't think that's inherently problematic, it's just an interesting bootstrapping challenge. \$\endgroup\$ – Steve Bennett May 26 at 1:00
0
\$\begingroup\$

Price this word

So, I'm going shopping in the Word Market™. There are shelves of words which I can buy around me, but I only have one dollar bills and the change machines at the market are broken. To add to the problem, there are words with... non-word characters in them. That's no good, I can't buy those... can you help me figure out which words I can buy and which I can't?

Task

So, I can only buy words that consist of only alphabetical characters and are worth a dollar. To determine a word's value, you have to sum the letters in the word where A = 1¢, B = 2¢... to Z = 26¢. I'm too lazy to look at the output and judge whether it is equal to one dollar (100 cents), so you'll need to return a specific value for words equal to a dollar (...or 100 cents) and a specific value for not equal to a dollar (I'm going to stop including this).

I'll also offer a bonus byte reduction: if your code returns whether the word is less than a dollar, equal to a dollar, greater than a dollar, or invalid (e.g. <, =, >, x), your score will be multiplied by 3/4.

SANDBOX NOTE: Is this a balanced bonus value?

Examples

Word          Non-bonus value     Bonus value

a                  false               <
b                  false               <
printera           false               >
$word              false               x
printer            true                =

And here's a JavaScript snippet you can use if you want to check for non-bonus validity:

(it's also 52 bytes; you can use it by calling f())

f=s=>([...s].map(x=>a+=parseInt(x,36)-9),a==100),a=0

Anyways, standard loopholes apply, shortest answer in bytes wins (but I'll add shortest answers for esoteric and functional languages)... you get the idea.

| |
\$\endgroup\$
  • 1
    \$\begingroup\$ In general, bonuses in code golf are seen as something to avoid \$\endgroup\$ – math junkie May 28 at 2:45
  • \$\begingroup\$ Standard Loopholes \$\endgroup\$ – math junkie May 28 at 2:46
  • 2
    \$\begingroup\$ This challenge doesn't seem interesting to me. We've already have plenty of challenges about summing up characters in a string, and having to determine whether a string contains non-word characters just seem like tacked on challenge that makes the whole thing more cumbersome. \$\endgroup\$ – Surculose Sputum May 28 at 15:40
  • 2
    \$\begingroup\$ What's a bit ironic about this is that after you posted this you went on to write a program that went through words in the English language and summed up their values depending on what character they were, sharpness of a word \$\endgroup\$ – Ethan Slota May 28 at 20:53
  • \$\begingroup\$ Never say I like the sharpness challenge either. :P But I do think that that challenge is a bit more interesting, due to the somewhat arbitrary mapping of letter to values. Yours just straight up uses the vanilla alphabetical order. \$\endgroup\$ – Surculose Sputum May 29 at 14:53
  • \$\begingroup\$ You do have a point; in Jelly or 05AB1E there's probably a builtin that would sum up a string based on values like I want people to do. \$\endgroup\$ – Ethan Slota May 29 at 21:50
0
\$\begingroup\$

Magic card trick: Hide information by flipping cards

(This is inspired by a series of questions on puzzles.stackexchange.com: 10, 8, 7)

Fix two integers m and u. Your task is to perform the following magic trick:

  • A Magician brings a pack of m distinct cards, and leaves the room.

  • In their absence, a volunteer from the audience shuffles the deck and arranges all cards in a line, in any order they want.

  • Still in the absence of the magician, their assistant flips u cards. On the table are the n cards, still in the order chosen by the volunteers, but u are face down, leaving only mu cards face up.

  • The magician returns, and from the order of the cards alone, knows each card.

Input:

m - number of cards.

u - number of cards to flip face down.

  • You may assume 0 < u < m.

Output, if the trick is possible for m and u:

f - an mapping assigning to each sequence the order the assistant will create by flipping cards.

  • If the trick is to work, this mapping must be bijective.
  • Use the integers 1...m (or 0...m−1), or single letters as card values.
  • Use any meaningful way to express f: a hash maps, a table, a function.
  • Use a fixed placeholder for any face-down cards.

Output, if the trick is impossible for given values of m and u

This case should be indicated in a meaningful way.

Example output (m=3, u=1):

Using the digits 0, 1, and 2 as cards, and _ for their flipside:

012 01_
021 0_1
102 _02
120 12_
201 2_1
210 _10

(For these values of m and u, this isn't very impressive as a magic trick, of course.)

Example output (m=4, u=2):

Using 1, 2, 3, and 4 for the cards and 0 for their flipside, and a JSON representation:

{"1234":"0034","1243":"0043","1324":"0024","1342":"0042","1423":"0023","1432":"0032",
"2134":"0104","2143":"0103","2314":"0014","2341":"0041","2413":"0013","2431":"0031",
"3124":"0120","3142":"0102","3214":"0204","3241":"0201","3412":"0012","3421":"0021",
"4123":"4003","4132":"0130","4213":"0203","4231":"0230","4312":"0302","4321":"0301"}

This is correct because as required, the keys are all permutations of 1234, each value has two cards face-down and the other cards match the original sequence, and each value appears only once.

Scoring

This is code-golf. Shortest solution wins.

| |
\$\endgroup\$
  • \$\begingroup\$ I think I should not allow all that input/output flexibility and require some fixed format. For example: input is u and a string whose (unique) characters are the decks. Require _ as placeholder. Require a fixed table format. \$\endgroup\$ – retzler May 29 at 4:27
  • 1
    \$\begingroup\$ There were some clarity issues I had while reading this, but as is I think this has a much bigger problem. It seems very likely to me that outputs for large m will be prohibitively difficult to verify, given the complexity of the proofs from the related puzzling challenges. There are many ways you could approach this, like upper bounding m, making this a test-battery, or making a code-challenge where the goal is to find the maximum u for the highest m. There are probably other ways to handle this, so these are just some starting ideas. Thanks for using the sandbox! \$\endgroup\$ – FryAmTheEggman May 29 at 19:23
  • \$\begingroup\$ Thank you for the valuable feedback @FryAmTheEggman. The proofs from the linked puzzles are long because they're reasoning & looking for insight. To just verify the list, two steps are sufficient: verify that f*(*x) is obtained from x by replacing u symbols with _, and that f is a bijection and defined for all permutations. Non-golfed solution including full tests . The output will still be huge, no chance of cursory manual verification. I didn't know about alternatives to code-golf, actually! I'll be looking into these. \$\endgroup\$ – retzler May 29 at 21:44
  • \$\begingroup\$ No problem! I do want to clarify though - I was aware of the ability to prove by exhaustion when I posted my first comment. However, I did base my assessment of it being a true problem around you not wanting a completely naive brute force search through each strategy, which I see now wasn't correct, so if you are fine with that then there isn't really a problem. But of course, if you want anything besides those solutions I'd recommend looking into what I suggested, or asking in our chat room for other people's points of view. \$\endgroup\$ – FryAmTheEggman May 29 at 22:43
0
\$\begingroup\$

_

| |
\$\endgroup\$
  • \$\begingroup\$ What kind of numbers can be in the sequence? \$\endgroup\$ – xnor May 22 at 10:30
  • \$\begingroup\$ @xnor Integers, basically. \$\endgroup\$ – user92069 May 22 at 10:35
  • \$\begingroup\$ Would the test cases that time out, 1,2 and 7,4, be excluded by "the input will always be provided in a way such that it won't take forever to zero the accumulator"? No product of exclusively odd numbers can end up being divisible by a power of 2. \$\endgroup\$ – Unrelated String May 23 at 9:35
  • 1
    \$\begingroup\$ @UnrelatedString Thanks for nothing that; I've removed these test cases. \$\endgroup\$ – user92069 May 23 at 9:46
  • 2
    \$\begingroup\$ Now this post is zeroed eventually \$\endgroup\$ – l4m2 Jun 5 at 1:36
0
\$\begingroup\$

Mobile games money representation

In many mobile clicker games where the player is usually required to tap on the screen to make money (in order to buy upgrades for you to generate money faster), it gets to a point in the game that the money made per second is so big that if represented in its "normal" form, it would clutter the mobile screen. Imagine showing the user that they are making \$1,000,000,000,000,000,000,000,000\$ per second in a small mobile phone screen!

From my experience as a regular player of these type of games, I have noticed that most of them represent bigger numbers by using letters. If the number of money per second is a number less than \$10,000,000\$ then print the number as is. Otherwise, if the number is in the millions (but \$ \geq 10,000,000\$), for example \$ 102,000,000\$ it should print \$102M\$. If it is in the billions, it should print \$102B\$. You should use \$T\$ for trillion and \$Q\$ for quadrillion.

As you can notice, the next would be quintillion which would also use the letter \$Q\$ if followed the pattern. Instead of following this pattern which can be confusing at one point, game developers usually start a new pattern: Quintillion is used with the suffix \$AA\$, sextillion is \$AB\$, septillion is \$AC\$ and so on.

Notice that this pattern would go until \$AZ\$ and if the player is making more money than that, it would start from \$BA\$, \$BB\$, ..., \$BZ\$, ...,\$ZA\$, \$ZB\$, ... , \$ZZ\$ which for our problem we will assume is the limit one player can make per second.

Task

Given an integer \$x\$ where \$0 \lt x \leq 999\$ and a natural number \$y\$ where \$y \gt 0\$ representing the number of zeroes the number has, output the number in a "mobile game money representation" as described above.

Observations

  • The number of zeroes that \$y\$ represent does not include the possible zeroes \$x\$ might have! Example: if \$x = 100\$ and \$y = 6\$, you should output \$100M\$ and not \$1,000,000\$

Test Cases (x, y --> game money representation)

100,  6 --> 100M
100,  5 --> 10M 
100,  4 --> 1000000
1,   12 --> 1T
10,  12 --> 10T
100, 12 --> 100T
1,   18 --> 1AA
10,  18 --> 10AA
100, 18 --> 100AA
# To be added...

Meta questions

  1. Is this a duplicate? I have looked around but didn't find anything similar.
  2. Is the wording confusing? I'm open to recommendations!
  3. I haven't written a program yet so the test cases might be wrong (I'll add more later).
  4. Pretty much any feedback is appreciated!
| |
\$\endgroup\$
  • 2
    \$\begingroup\$ Looks like it needs some test cases with decimal points, e.g. 123, 17 -> 12.3AA. \$\endgroup\$ – Bubbler Jun 1 at 0:20
  • \$\begingroup\$ Shouldn't 100, 4 become 1M? \$\endgroup\$ – Surculose Sputum Jun 1 at 13:03
  • \$\begingroup\$ @SurculoseSputum In these games, when the number is small enough (as I said in the second paragraph), if the number is less than 10 million, then it is printed in its "normal" form. The abreviations starts after 10 million. \$\endgroup\$ – ihavenoidea Jun 1 at 19:33
  • \$\begingroup\$ Suggest cases where \$y\$ don't just go the AA \$\endgroup\$ – l4m2 Jun 19 at 4:24
  • \$\begingroup\$ Thanks all, I'm pretty busy lately unfortunately. Whenever I get the time I'll try to update the challenge \$\endgroup\$ – ihavenoidea Jun 19 at 21:59
0
\$\begingroup\$

Shift the letters, soldier !

posted, finally

| |
\$\endgroup\$
  • \$\begingroup\$ Thank you for sandboxing this. I usually recommend doing so for at least a week, and periodically ask for review in TNB. \$\endgroup\$ – Adám Feb 28 at 9:09
  • \$\begingroup\$ I think people would be forced to do the bonus in this case because of the -30% margin. I got a 42 without bonus but a 57*0.7=39.9 with bonus in JS. \$\endgroup\$ – Shieru Asakoto Feb 29 at 3:16
  • \$\begingroup\$ Bonuses are discouraged for a variety of reasons. I would strongly recommend either making it mandatory or completely leaving it out. \$\endgroup\$ – FryAmTheEggman Mar 1 at 18:58
  • \$\begingroup\$ The main challenge is add by position, the bonus challenge is minus by position. So it's a good idea to completely leave the bonus out. \$\endgroup\$ – user92069 Mar 2 at 0:29
  • \$\begingroup\$ Thanks for the comments, I'll remove the bonus as it will never be balanced enouth to be interesting. I'll add some example as soon as I can. \$\endgroup\$ – The random guy Mar 3 at 20:02
  • \$\begingroup\$ I would say that allowing the usage of the ascii range 1 to 255 or a language's code page could allow for some interesting golfs :) \$\endgroup\$ – RGS Mar 3 at 20:39
  • \$\begingroup\$ Use asciii values from 0 to 255 was my original plan, but I'm afraid some interestings languages would be disadvantaged. Also, wouldn't the usage of language's code page be too permissive ? \$\endgroup\$ – The random guy Mar 4 at 15:51
  • \$\begingroup\$ @Therandomguy it depends on what you mean by "too permissive". Sometimes it is done, as it may allow some languages to do some funny things. As to the range being from 0 to 255, I don't see it hurting any language at all, but of course I may be missing something :) \$\endgroup\$ – RGS Mar 4 at 21:36
  • \$\begingroup\$ Are you interested in re-posting it? \$\endgroup\$ – user92069 Mar 6 at 7:38
  • \$\begingroup\$ This weekend I'll post it, I just need some time creating the examples \$\endgroup\$ – The random guy Mar 6 at 8:25
  • \$\begingroup\$ I'd be glad to see it posted in Main! \$\endgroup\$ – user92069 Mar 25 at 12:19
  • \$\begingroup\$ Finally posted it in main \$\endgroup\$ – The random guy Jun 3 at 7:45
0
\$\begingroup\$

Compute the pointiness, sharpness and smoothness of a letter

Inspired by Determine the sharpness of a word.
You are given an uppercase letter of the English alphabet as input. You have to compute (and output) its pointiness, sharpness and smoothness. Since it is difficult to define these objectively, here's a table of the outputs:

            A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
pointiness: 2 0 2 0 3 3 2 4 4 2 4 2 2 2 0 1 1 2 2 3 2 2 2 4 3 2
sharpness:  1 2 0 2 2 1 1 0 0 1 0 1 3 2 0 1 0 1 0 0 0 1 3 0 0 2
smoothness: 0 2 1 1 0 0 1 0 0 1 0 0 0 0 1 1 1 1 2 0 1 0 0 0 0 0

Transposed version (first lists the letter, then the pointiness, then the sharpness and then the smoothness) (like a true CGCC user, I transposed it with Jelly and added spacing with Retina):

A 2 1 0
B 0 2 2
C 2 0 1
D 0 2 1
E 3 2 0
F 3 1 0
G 2 1 1
H 4 0 0
I 4 0 0
J 2 1 1
K 4 0 0
L 2 1 0
M 2 3 0
N 2 2 0
O 0 0 1
P 1 1 1
Q 1 0 1
R 2 1 1
S 2 0 2
T 3 0 0
U 2 0 1
V 2 1 0
W 2 3 0
X 4 0 0
Y 3 0 0
Z 2 2 0

Bonus imaginary internet points if you find a language where this is built-in.

This is tagged , so the shortest answer wins.

Sandbox stuff

  • Is this not a duplicate?
  • Is the table computed correctly? (the only ones that don't seem certain with the current font are I's pointiness, G's sharpness and S's smoothness)
| |
\$\endgroup\$
  • \$\begingroup\$ After fiddling about a bit, I think this should probably have enough patterns that mindlessly compressing the numbers won't be the best strategy. Still, I could be wrong, but here is what I used to see roughly how long such an approach would be (I encoded each set of values to a base 5 number, then in turn encoded that list of numbers into a base 61 number). Separately, you probably want to include the data in a more copy-pastable way. \$\endgroup\$ – FryAmTheEggman Jun 3 at 20:34
0
\$\begingroup\$

Is this a simple cutting template?

A simple cutting template is a rectangle that can be recursively cut into smaller rectangles using only full-width cuts.

If you prefer a bottom-up description, then:

  • A single rectangle is a simple cutting template with 0 cuts.
  • Two simple cutting templates of the same width (or length) can be joined along their common side into a larger simple cutting template.

Input: A diagram of a rectangle subdivided into smaller rectangles, or a list of rectangles in some standard format, e.g. position and size.

Output: A truthy value if the diagram is a simple cutting template.

Note that if you take input as a diagram then all of the rectangle edges will use the same character, whearas in the truthy examples below, some of the edges have been replaced with digits to show a possible ordering of cuts while the falsy examples have the smallest portion of the input that is not a simple cutting template marked on them.

####2################
#   2               #
111111111111111111111
#                   #
#                   #
#                   #
111111111111111111111
#     2   2   2 4 4 #
3333332   2   2 4 4 #
# 4   2   2   2 4 4 #
# 45552   2   2 454 #
# 4 6 2   2   2 4 4 #
# 4 6 2   2   2 4 4 #
# 4 6 2   2   2 4 4 #
33333323332   2 4 4 #
#     2   2   2 4 4 #
#     23332   2 4 4 #
#     2   2   2 4 4 #
#     2   2   233333#
#     2   2   2     #
######2###2###2######

-> Truthy

##2#####4############
# 2     4           #
# 2333333333333333333
# 2         6     4 #
# 25555555555555554 #
# 2 6   6     8   4 #
# 2 6   67777777774 #
# 2 6   6         4 #
# 2 6   6         4 #
# 2 6   6         4 #
111111111111111111111
#               2   #
#               2333#
#               2   #
111111111111111111111
#   2             2 #
#   233333333333332 #
#   2 4 4     4   2 #
#   2 4 4555554   2 #
#   2 4 4     4   2 #
####2#############2##

-> Truthy

#####################
#                   #
#                   #
#                   #
111111111111111111111
# 2   4           2 #
# 2   4           2 #
# 2   4           2 #
# 23333333333333332 #
# 2     4   4 6 4 2 #
# 2     45554 6 4 2 #
# 2     4 6 4 6 4 2 #
# 2     4 6 4 6 4 2 #
# 2     4 6 4 6 4 2 #
# 2     4 6 45554 2 #
# 2     4 6 4   4 2 #
# 2     4 6 4   4 2 #
# 2     4 6 4   4 2 #
# 2     4 6 4   4 2 #
# 2     4 6 4   4 2 #
##2#####4#6#4###4#2##

-> Truthy

#####################
#               # # #
################# # #
#               # # #
#               # # #
#               # # #
?????????############
?     # ?     #     #
?     # ?     #     #
?     # ?     #     #
?     ##?     #     #
?     # ?     #     #
?###### ?############
?     # ? #       # #
?     # ? #       # #
?     # ? #       # #
?###### ?##       ###
? #   # ? #       # #
? ######? #       # #
? #     ? #       # #
?????????############

-> Falsy

?????????????????????
?     # # # # #     ?
?###### # # # #     ?
?     # # # # #     ?
?     # # # # ######?
?     # # # # #     ?
?###### # ##########?
? #   # # #         ?
? ##### # #         ?
? # # # # #         ?
? # # # # #         ?
? # # # # #         ?
? ####### #         ?
? #     # #         ?
? #     ############?
? #     #     #     ?
? #############     ?
? #     #     #     ?
? ##################?
? #         #       ?
?????????????????????

-> Falsy

#####################
#       #   #     # #
################### #
#                 # #
#####################
# #                 #
# ###################
# #   #             #
# ###################
# #   #     #       #
# ###################
# #                 #
# ???????????????????
# ?   #             ?
# ?   #             ?
# ?   #             ?
# ?   ##############?
# ?   #   #         ?
# ?########         ?
# ?       #         ?
##???????????????????

-> Falsy

This is , so the shortest program or function that breaks no standard loopholes wins.

| |
\$\endgroup\$
  • \$\begingroup\$ I think you should include an explicit definition: 'A simple cutting template is a rectangle that can be recursively cut into smaller rectangles using only full-width cuts.' \$\endgroup\$ – Dingus Jun 6 at 4:06
  • 1
    \$\begingroup\$ @Dingus Thanks for pointing that out, I think I must have accidentally edited it out by mistake when writing the sentence for the output. \$\endgroup\$ – Neil Jun 6 at 10:29
  • 1
    \$\begingroup\$ I'd prefer one or two small examples with extra markings and then a list of copy-pasteable test cases. \$\endgroup\$ – Zgarb Jun 6 at 11:13
0
\$\begingroup\$

ax + by, a & b are coprime

Backstory

A doctor in Berlin, after analyzing his medical history, has realized that all of the results of his integral measurement results can be represented in the form of \$23x+28y\$, where \$x\$ and \$y\$ are integers.

However, he could have extended his theory. \$23\$ and \$28\$ can be replaced by any two coprime numbers, and this theory would still hold. (He didn't have time to write his theory in a paper, that's quite awful.)

Task

Without examples, I'll never be convinced that this nonsensical theory holds!

Given \$the\ output\ of\ (ax+by)\$ (let's call it \$z\$), \$x\$, and \$y\$, find the smallest pair of \$(a,\ b)\$ that makes \$ax + by = z\$ true.

Example cases


| |
\$\endgroup\$
0
\$\begingroup\$

Duplicate of Find the minimum edit distance between two strings

| |
\$\endgroup\$
0
\$\begingroup\$

Partition distance

Quoting Anush:

I am very glad to provide a service to fill in the terrible gap in edit distance questions which codegolf.se has had. When there are as many edit distance questions as quine questions my job will be done.

--Anush

Task

Given a binary string consisting only of 0's and 1's, partition the binary string (divide the string into consecutive substrings), and determine the minimal edit distance in order to transform one piece into another, left to right. You need to output the sum of the edit distances between consecutive blocks.

Example

I'm going to make a reference implementation to find the optimal partitions. But that's after I dump all my ideas, though.

011010110111

We partition the string like this:
[011][010][110][111]

And then find the cumultative edit distance between each 2 pairs of partitioned strings:
[1 1 1]

Then, we sum the list of partitions.
[3]

So 3 is a possible output for this binary string. However, you need to find the minimum edit distance, so this might not be the correct answer.

Another example

001001010

We partition this string:
[001][001][010]

And then find the mimimal edit distance between each piece.
[0 1]

Therefore, our (non-optimal?) output for 001001010 is 1 ([0 1] summed).

Rules

  • The edit distance between two strings is the minimum number of single character insertions, deletions and substitutions needed to transform one string into the other.
  • The input is guaranteed to have at least length 3.
  • The pieces of your partition don't have to be the same length.
| |
\$\endgroup\$
  • \$\begingroup\$ What do you mean by "partition the input string"? Can I choose any partition I want as long as it's not all singletons or the entire thing? Or do I have to find one that's optimal in some sense? Why is the all-singletons case disallowed? Is the output the sum of the edit distances between consecutive blocks? From the examples I guess it is but you should say it explicitly. \$\endgroup\$ – Zgarb May 31 at 18:50
  • \$\begingroup\$ @Zgarb "partition the input string" means divide the input string into (not necessarily equal) consecutive substrings. You need to find one that's optimal, I've emphasized that. I allowed the all-singleton case; I specified that the output is the edit distance sum between consecutive blocks explicitly. \$\endgroup\$ – user92069 Jun 7 at 4:36
  • \$\begingroup\$ It should still be made clearer that the output is the minimum over all partitions. \$\endgroup\$ – Zgarb Jun 7 at 20:21
0
\$\begingroup\$

Pristine Polyglot Quines

As the title says, you are to create a pristine program which outputs its own source code in as many languages as possible. A pristine program, taken from here, is:

Let's define a pristine program as 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 1 <= N < program length.

For example, the three character Python 2 program

8 is a pristine program (thanks, Sp) because all the programs resulting from removing substrings of length 1 cause errors (syntax errors in fact, but any type of error will do):

8`
``
`8

and also all the programs resulting from removing substrings of length 2 cause errors:

`
`

If, for example, `8 had been a non-erroring program then `8` would not be pristine because all the results of substring removal must error.

A pristine quine is a pristine program that outputs its own source code, according to our standard quine rules (so no empty or literal only programs).

You are to write, in as many languages as possible, a pristine quine.

  • Your code must work in a minimum of two distinct languages
  • Different versions of a language do not count as different languages. Therefore, Python 2 and Python 3 are considered the same language.
  • Your program must be pristine in all languages used
  • This is , so the answer with the most languages wins
    • In case of a tie breaker, the longest solution, in bytes, wins

Meta

| |
\$\endgroup\$
  • \$\begingroup\$ Wow, pristine quines are already hard enough, and now you want it to be a polyglot too? Especially since polyglots often rely on one language ignoring the executing part of the other. Also, does it need to pristine in both languages, or both combined (i.e. removing a section can work in language A, as long as it errors in language B)? \$\endgroup\$ – Jo King Nov 13 '19 at 5:58
0
\$\begingroup\$

Compute the factorial, on both sides of 0

Why, why, why do factorials stop at zero? (Yes there are actual reasons). Make a factorial function (or full program) that doesn't stop at zero!

Your code-golfed program should, given an non-zero integer n (can be positive or negative, the rule still applies), find the product of the range n to -n excluding 0.

Graph that at least works for positive numbers

Sample IO

 Input          | Output
----------------|------------
0               | 1 (product of 0 and -0 without 0 / empty product)
2               | 4 (2*1*-1*-2)
3               | -36 (3*2*1*-1*-2*-3)
4               | 576 (4*3*2*1*-1*-2*-3*-4)
-4              | 576

Probably not a duplicate, but it might not be that much of a challenge.

| |
\$\endgroup\$
  • \$\begingroup\$ Would the input always be positive? Is n=0 a possible input? \$\endgroup\$ – Bubbler Jun 11 at 23:02
  • \$\begingroup\$ @Bubbler For now I'll say 0 is undefined, might change it later before posting if I have a good idea. \$\endgroup\$ – Wezl Jun 12 at 13:53
  • 1
    \$\begingroup\$ As it is, isn't this always the factorial of the absolute value of the input squared, then made negative if the input is odd? - except in the edge case for zero? The sign of the input doesn't really appear to matter, which is an odd feeling. \$\endgroup\$ – FryAmTheEggman Jun 12 at 16:24
  • \$\begingroup\$ @FryAmTheEggman Yes, see this graph of the values. Is that a bad thing? Do you have a better suggestion? \$\endgroup\$ – Wezl Jun 12 at 20:44
  • \$\begingroup\$ "downvotes mean nothing but rudeness" - I downvoted this because I do not think "compute \$|n|!^2 \cdot (-1)^n\$" is a good challenge. I can't see how disagreement is rude. The requirements here seem completely arbitrary to me. This will result in the exact same approaches as were used in the factorial challenge. \$\endgroup\$ – my pronoun is monicareinstate Jun 14 at 8:27
  • 1
    \$\begingroup\$ I think it is a bad thing in that it becomes dangerously close to a dupe of the factorial problem. I probably wouldn't hammer it immediately, but if most of the responses basically worked for both or many others had the same concern I'd probably close it. I'm not sure of a good way to modify this to be better, so unfortunately I don't have any suggestions at the moment. I will let you know if something occurs to me. \$\endgroup\$ – FryAmTheEggman Jun 15 at 20:09
  • \$\begingroup\$ @FryAmTheEggman I wouldn't consider it a dupe but I wouldn't consider it a good question after all based off of what my pronoun is monicareinstate said. \$\endgroup\$ – Wezl Jun 16 at 21:47
  • 1
    \$\begingroup\$ If you consider 0 as a valid input, I suggest that its expected output be 1, which corresponds to the empty product (Wikipedia). \$\endgroup\$ – Bubbler Jun 17 at 3:52
  • \$\begingroup\$ For the interesting-ness, I believe it can be interesting in at least some languages (which IMHO justifies the value of having such a challenge). FWIW, I have two J solutions of equal length, one using the factorial built-in ! and the other not using it. \$\endgroup\$ – Bubbler Jun 17 at 3:53
  • \$\begingroup\$ I'd likewise close this as a duplicate, but I'm known for having much broader standards than the rest of the community about what questions are closeworthy, so make of that what you will. \$\endgroup\$ – pppery Jun 18 at 2:38
  • \$\begingroup\$ I'll just abandon this, but if @Bubbler wants to post it, they can. \$\endgroup\$ – Wezl Jun 18 at 21:17
0
\$\begingroup\$

Default Lightning Strike

Introduction:

Inspired by this reddit question: ELI5: Why does lightning travel in a zig-zag manner rather than a straight line?

Although it's more complex than this, in general multiple lightning paths will randomly check its immediate surrounding for the direction with least resistance (based on air pressure, temperature, composure, humility, etc.) and travel in that direction. As soon as one of the paths reaches the ground, that entire path has the least resistance and most (although not all) of the ions will accumulate in that path, causing the lightning flash and thunder.
Here a slow-mo video of a lightning strike to get an idea.

Challenge:

Input: An integer \$h\geq3\$ and an integer \$1\leq p\leq\left\lfloor\frac{h}{2}\right\rfloor\$

Output: Each step of the ASCII animation of a lightning strike, with a cloud to earth height of \$h\$ and up to \$p\$ paths

We start with a lightning ion at the cloud, with a lowercase letter of your own choosing (i.e. b). This ion will travel in a random direction (horizontally, vertically, or (anti-)diagonally), except where this path itself comes from. Every 'tick' it also has a 20% chance of branching out into two paths, as long as we haven't reached \$p\$ paths yet. Each of these paths will behave the same.
As soon as any path hits the ground based on the height \$h\$, all letters of that particular path will become uppercase, and in the final 'tick' after that, only this uppercase path will remain.

Challenge rules:

  • Paths can intersect with other paths
  • Paths can travel upwards beyond the height of our starting point
  • Output can be in any reasonable format. Could be a list of multi-line strings for each 'tick'. Could be a list of character-matrices for each 'tick'. Could be pretty-printed to STDOUT (with clear non-whitespace separation between each 'tick' - i.e. a single character like a comma or semi-colon, or a line of --- or ___)
  • Trailing spaces for each line of a tick are optional (leading as well, as long as the lightning bolts are still correct)
  • If multiple paths strike the ground in the same 'tick', only the first one of those two (or more) paths will become the lightning strike. The order in which paths are created are therefore important, so keep that in mind.

Examples:

This may all sound pretty vague, so here a couple of examples:
(I've added trailing spaces for each step with spaces, but you don't necessarily have to do so as mentioned in the challenge rules.)

Example 1: \$h=3, p=1\$

Tick 1:
"b"
" "
" "
Tick 2 (random direction: right):
"bb"
"  "
"  "
Tick 3 (random direction: up-left):
"b "
"bb"
"  "
"  "
Tick 4 (random direction: down-left):
" b "
"bbb"
"   "
"   "
Tick 5 (random direction: down):
" b "
"bbb"
"b  "
"   "
Tick 6 (random direction: up-right):
Note that this overlaps with a previous step in this path, which is fine.
" b "
"bbb"
"b  "
"   "
Tick 7 (random direction: down-right):
" b "
"bbb"
"b b"
"   "
Tick 8 (random direction: down):
" b "
"bbb"
"b b"
"  b"
Tick 9 (lightning strike):
" B "
"BBB"
"B B"
"  B"
Tick 10 (extra tick to remove all other paths, although there are none right now):
" B "
"BBB"
"B B"
"  B"

Example 2: \$h=5, p=2\$

Tick 1:
"b"
" "
" "
" "
" "
Tick 2 (random direction: down-left):
" b"
"b "
"  "
"  "
"  "
Tick 3 (random direction: down-left):
"  b"
" b "
"b  "
"   "
"   "
Tick 4 (random direction: right):
"  b"
" b "
"bb "
"   "
"   "
Tick 5 (random 20% path split; random direction 1: top-right, random direction 2: right):
"  b"
" bb"
"bbb"
"   "
"   "
Tick 6 (random direction 1: top-left, random direction 2: down):
" bb"
" bb"
"bbb"
"  b"
"   "
Tick 7 (random direction 1: left, random direction 2: down-right):
"bbb "
" bb "
"bbb "
"  b "
"   b"
Tick 8 (lightning strike of path 2):
"bbB "
" Bb "
"BBB "
"  B "
"   B"
Tick 9 (extra tick to remove all the other paths, which is path 1 in this case):
"  B "
" B  "
"BBB "
"  B "
"   B"

General rules:

  • This is , so shortest answer in bytes wins.
    Don't let code-golf languages discourage you from posting answers with non-codegolfing languages. Try to come up with an as short as possible answer for 'any' programming language.
  • Standard rules apply for your answer with default I/O rules, so you are allowed to use STDIN/STDOUT, functions/method with the proper parameters and return-type, full programs. Your call.
  • Default Loopholes are forbidden.
  • If possible, please add a link with a test for your code (i.e. TIO).
  • Also, adding an explanation for your answer is highly recommended.

Sandbox Questions:

  • Should I perhaps use a different letter of the alphabet per path?
    • If yes: what would happen when different letter-paths overlap? I assume the top one will be visible per 'tick', but if lightning is struck it should still change it to the underlying letter as uppercase. In either case, you'll have to keep track of each individual path and uppercase only the one that struck the ground (first).
  • Any additional rules or things that are unclear?
  • An additional relevant tag?
  • More examples with more paths and/or larger height?
  • A different path percentage instead of hard-coded \$\frac{1}{5}\$ / 20%.
| |
\$\endgroup\$
0
\$\begingroup\$

Sort numbers using as few distinct bytes as possible

Task

Write an algorithm that takes as input an ordered list (array, linked list, etc...) of numbers and outputs an ordered list containing the same numbers sorted by their value (ascending or descending).

The numbers may be represented using the most convenient format to you, with the only restriction that there must be a way to encode 256 distinct numbers. You are not allowed to use built-in sorting functions/algorithms.

Scoring criteria

Let \$c\$ be the number of distinct bytes in your code* and let \$s\$ be the number of bytes in your code*.
*Or its UTF-8 representation

The score is equal to \$c^2 + s\$. The answer with the lowest score wins!

Examples (imagine these are sorting algorithms):

  • ababccbaacbabcba\$c=3, s=16, score=25\$
  • aAbcd€f\$c=9, s=9, score=90\$
  • bytes 16 ee 3c 79 ee\$c=4, s=5, score=21\$

I'm open to suggestions, especially about the score formula.

| |
\$\endgroup\$
  • \$\begingroup\$ I see that this is your first attempt at writing a challenge. Thank you so much for using the sandbox! \$\endgroup\$ – Adám Jun 25 at 22:16
  • \$\begingroup\$ Please note that it is very hard to write good challenges that restrict solutions from certain things. This is because it is hard to define exactly what is prohibited in every language, and it is also hard to determine if any prohibited feature was used. \$\endgroup\$ – Adám Jun 25 at 22:19
  • 1
    \$\begingroup\$ @Adám So how should I prevent trivial answers? Maybe "built-in sorting functions/algorithms" is a bit vague. \$\endgroup\$ – D. Pardal Jun 25 at 23:04
  • \$\begingroup\$ We don't prevent trivial answers in most cases. Btw, if I accept plain numbers as input, may I assume the input is a list of integers between 0 and 255 inclusive? \$\endgroup\$ – Bubbler Jun 25 at 23:46
  • \$\begingroup\$ How about this: "You are not allowed to use any built-in function/command that can take an ordered container and output the sorted result. Anything else is OK." \$\endgroup\$ – Bubbler Jun 25 at 23:54
  • \$\begingroup\$ I think a good solution would be to allow built-in solutions, but to compile (in advance, so that it can be posted very quickly, probably via the "answer your own question" feature) a community wiki answer listing trivial 1-byte solutions. \$\endgroup\$ – my pronoun is monicareinstate Jun 26 at 4:17
  • \$\begingroup\$ @Bubbler Would still be unclear if J's /:~ or /:] were allowed or not. \$\endgroup\$ – Adám Jun 26 at 6:15
  • \$\begingroup\$ @D.Pardal Why do you want to prevent trivial answers? \$\endgroup\$ – Adám Jun 26 at 6:20
  • \$\begingroup\$ I wanted to prevent built-in functions because otherwise most answers would be exactly the same as the ones from this question. Maybe the easiest way to solve this would be to replace the task of sorting an array with another. \$\endgroup\$ – D. Pardal Jun 26 at 7:15
  • 1
    \$\begingroup\$ Yes. Banning built-in has long been considered a bad idea. \$\endgroup\$ – user202729 Jun 26 at 11:57
0
\$\begingroup\$

Fix mispellings

Wikipedia has a list of common misspellings, and there is also a machine-readable version!

Your challenge is to input a string and fix the mispellings in it.

The parituclar list we'll be using is https://en.wikipedia.org/w/index.php?title=Wikipedia:Lists_of_common_misspellings/For_machines&oldid=962756669#The_Machine-Readable_List. Note that even if the list changes, you must use this version. Here's a pastebin link: https://pastebin.com/j03aL98d.

Each line in the list is in the format INPUT->OUTPUT1, OUTPUT2, OUTPUT3, ... (of course, there may be more or less possible outputs, or even just one). That means that for input INPUT you must output exactly one of the possible outputs OUTPUT....

This is tagged , so the shortest answer wins.

Sandbox stuff

Should I add more misspellings to the post, or should I remove them?

| |
\$\endgroup\$
  • \$\begingroup\$ Related \$\endgroup\$ – pppery Jul 2 at 14:23
  • \$\begingroup\$ @pppery While the idea is probably related, I don't think the solutions would be related at all. \$\endgroup\$ – my pronoun is monicareinstate Jul 2 at 14:26
  • \$\begingroup\$ What is the input format? A plain English sentence (so we need to handle spaces, punctuation, capitalization), or is a list of words acceptable? How should capitalization be handled (some entries look like Tolkein->Tolkien and UnitesStates->UnitedStates; given unkown->unknown, what is the expected output of unkown, Unkown, UNKown, Tolkein, tolkein, TOLKEIN)? \$\endgroup\$ – Bubbler Jul 2 at 23:19
  • \$\begingroup\$ @Bubbler The input is a single entry in the list (the part before ->, of course). You do not need to handle capitalization ("tOLKEIN" is not "Tolkein"). (will clarify later). \$\endgroup\$ – my pronoun is monicareinstate Jul 3 at 2:11
0
\$\begingroup\$

Overlap characters

Put all the characters of a given list, following the order, in a sequence of bits keeping it as small as possible.

Rules

  • Write the bits of each character on a line.

  • You can overlap bits if they are equal.

  • You cannot change already written bits.

  • Extend the line, in both directions, if not all the bits fit in.

  • Always try to extend as less as possible.

Example

input :['a','&','1','.']
     0110 0001  // a
0010 0110      // &
           001 1000 1     // 1
                 00 1011 10 // .
                 
output :0010011000011000101110

input : "&1a."

       0010 0110      // &
          0 0110 001     // 1
0 1100 001  // a
                 0010 1110 // .
                 
output : 011000010011000101110

I/O rules

  • input can be any sequence of single byte elements.

  • output the resulting sequence of bits in any convenient method, no extraneous bits allowed (0 or 1)

| |
\$\endgroup\$
0
\$\begingroup\$

Distributive on myself

| |
\$\endgroup\$
0
\$\begingroup\$

Validating Words in Word Grids

A follow on from Generating Word Grids

Given a grid of letters, a set of co-ordinates and a dictionary of words, validate that the co-ordinates follow only cardinal direction changes, at least one of the co-ordinates touch an empty space in the centre of the grid, the resulting word is valid given the dictionary (taking into consideration any blank tiles) and return either the grid, with the letters at the co-ordinates removed along with the score of the word, or, if one of the conditions fail, the original grid and a score of -1.

Details

Please detail the format you want to accept coordinates in any reasonable format is acceptable.

Scoring

Letters are worth their values as per Scrabble:

0 points: blank tiles
1 point: E, A, I, O, N, R, T, L, S, U
2 points: D, G
3 points: B, C, M, P
4 points: F, H, V, W, Y
5 points: K
8 points: J, X
10 points: Q, Z

Bonus tiles (indicated by a lowercase letter, or ! for a blank tile) provide a *2 multiplier and stack (eg. if my co-ordinates spell gOLf I would earn (((2+1+1+4)*2)*2), 32 points).

Examples:

Input:

6,4 6,5 5,5 4,5 3,5 3,6 2,6 1,6
UWDESTKP?
ItDBaDEdI
TERMDYTSR
ROANJLEFT
EkCI OOsT
IPAJPGMNY
MZLORITVI
GwEGgPUeI
MNROYOEER

Output:

9
UWDESTKP?
ItDBaD dI
TERMDY SR
ROANJ  FT
EkCI  OsT
IPAJP MNY
MZLO  TVI
GwEGgPUeI
MNROYOEER

(spells RIGOLETE, (1+1+2+1+1+1+1))

Input:

0,3 0,4 0,5 0,6
UWDESTKP?
ItDBaD dI
TERMDY SR
ROANJ  FT
EkCI  OsT
IP  P MNY
MZL   TVI
GwE gPUeI
MNROYOEER

Output:

-1
UWDESTKP?
ItDBaD dI
TERMDY SR
ROANJ  FT
EkCI  OsT
IP  P MNY
MZL   TVI
GwE gPUeI
MNROYOEER

(spells DEST which doesn't appear in the dictionary)

Input:

5,6 4,6 4,7 4,8
UWDESTKP?
ItDBaD dI
TERMDY SR
ROANJ  FT
EkCI  OsT
IP  P MNY
MZL   TVI
GwE gPUeI
MNROYOEER

Output:

12
UWDESTKP?
ItDBaD dI
TERMDY SR
ROANJ  FT
EkCI     
IP  P  NY
MZL   TVI
GwE gPUeI
MNROYOEER

(spells MOsT, (3+1+1+1)*2)

Rules

This is so the shortest code in bytes wins.

  • The order is not important, it can be score then grid, or vice versa.
  • Any reasonable format can be used for I/O assuming it is consistent.
  • All standard loopholes are forbidden.


Questions for meta

Things have changed a lot in the time since I originally posted this, so rather than just posting I thought I'd bump for fredback.

  • What would the best way of using an associated dictionary be, taking it as input?
  • Obviously the input format for co-ordinates can be more flexible (0-based index, 1-based index, or something) is mentioning this enough?
  • Grid input format can be flexible too, mentioning this should be enough too?
  • Any other relevant tags?
| |
\$\endgroup\$
  • \$\begingroup\$ This looks pretty good to me. \$\endgroup\$ – Rɪᴋᴇʀ Sep 15 '17 at 18:20
  • \$\begingroup\$ Thanks @Pavel, I'll bear that in mind, i'm not sure how much interest there is based off of part 1, but I might still post this in the next week or so :) \$\endgroup\$ – Dom Hastings Sep 16 '17 at 9:21
0
\$\begingroup\$

Count the available moves

Just a brief Lay-out of an idea, I‘ll expand it further soon.

Given an input representing a chess board, containing between 1 and 16 pieces of each colour, with White to play, output the number of moves that White is able to play. Input may be any reasonable representation of a chess board and output should be a single positive integer in the most reasonable output format in your language. Code golf, so shortest wins.

| |
\$\endgroup\$
  • \$\begingroup\$ For the sake of avoiding retroanalytical issues, I suggest not counting en passant capture. Ignore castling too? \$\endgroup\$ – Rosie F Jul 19 at 17:57
  • \$\begingroup\$ @RosieF Given that I only want the current board state as input, I think not counting en passant makes the most sense. However, I don’t see any reason to ignore castling, aside from „it makes the challenge more difficult“, and I have no problem with that \$\endgroup\$ – caird coinheringaahing Jul 19 at 18:00
0
\$\begingroup\$

Infinite Mirrors Quine

This challenge is to create a program that prints out code that prints the original. Basically, this program should take an input, check if it's A, and if so, run section A. Otherwise, if it's B, run section B. Finally, if it's neither, print nothing. Section A should print the code in section B, and section B should print the code in section A. Section A's code and section b's code should not be identical. Shortest code wins!

| |
\$\endgroup\$
1
85 86
87
88 89
98

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .