556
\$\begingroup\$

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".

Get the Sandbox Viewer to view the sandbox more easily!

\$\endgroup\$
0

3988 Answers 3988

1
19 20
21
22 23
133
3
\$\begingroup\$

Reversed Multiple Pair

\$\endgroup\$
5
  • \$\begingroup\$ maybe give an example and a step by step of evaluating if it is reversed multiple? \$\endgroup\$ Jan 13 at 20:19
  • \$\begingroup\$ @thejonymyster Done \$\endgroup\$
    – Bgil Midol
    Jan 13 at 20:29
  • 3
    \$\begingroup\$ really simple, but it is clearly specified. seems like a decent easy challenge. To make it slightly more difficult you can make this a challenge of finding all reversed multiple pairs under a given limit. \$\endgroup\$
    – Razetime
    Jan 14 at 3:35
  • \$\begingroup\$ @Razetime codegolf.meta.stackexchange.com/a/9384/105116? \$\endgroup\$
    – Bgil Midol
    Jan 14 at 15:31
  • \$\begingroup\$ it's your choice whether that change makes it more interesting or whether it is an unnecessary burden. \$\endgroup\$
    – Razetime
    Jan 14 at 15:55
3
\$\begingroup\$

Cubax Folding Game

\$\endgroup\$
3
\$\begingroup\$

Happy new year string builder

Posted here.

\$\endgroup\$
2
  • \$\begingroup\$ The regex should probably be /^(have a )?happy new year( to you)?!*$/i (removed unnecessary grouping, added string start and end match, and the i tag means the search is case insensitive by default.) \$\endgroup\$
    – hakr14
    Feb 7 at 23:12
  • \$\begingroup\$ @hakr14 thanks, editing the answer. \$\endgroup\$
    – ophact
    Feb 8 at 6:07
3
\$\begingroup\$

The Con Man

The bots start with a balance of 100 points each. Each round is a 1v1 between two bots. One bot is the Proposer and the other is the Receiver.

P provides R with two numbers: think of it as a loan and repayment with interest. For example, P could propose (50, 60) which means that P wants to swap 50 points for 60 points with R. P also decides whether or to scam R. If R accepts, P can scam R by not upholding their end of the deal and instead taking the 50 points outright.

The twist is, R can see the outcomes of past transactions of P to determine whether or not to trust P and accept the offer.

The format of the tournament is that of a round robin where every bot will play P and R the same number of times against all opponents, in an unspecified order.

Whichever bot ends up with the most points wins.

The language of this challenge is JS.

Format (in TypeScript):

type Bot = {
  R(
    offer: [number, number], // loan, repay
    opponentBalance: number,
    pastTransactions: [number, number, number][] // loan, repay, outcome (0 -> accept, 1 -> reject, 2 -> scam)
  ): boolean,
  P(
    opponentBalance: number,
    pastTransactions: [number, number, number][]
  ): [number, number, boolean] // [loan, repay, scam]
}

Meta

  • Does this make for diverse enough strategies to be worthwhile?
  • Should more or less information about the opponent be supplied to the players?
\$\endgroup\$
2
  • \$\begingroup\$ And if the bot runs out of money, does it die or can it take a loan? It can't give out loans obviously right? \$\endgroup\$
    – ophact
    Feb 15 at 8:41
  • \$\begingroup\$ @ophact I think it should die since no reasonable strategy would accept a deal with a bot with no money. \$\endgroup\$ Feb 16 at 2:16
3
\$\begingroup\$

Largest rectangle in a skyline

\$\endgroup\$
3
\$\begingroup\$

Golfing Coins (suggested rewrite)

The challenge is to write a program that begins with a board like this:

O O X
O O X
O O X

The O's are coins. X's are empty.

Rules

Every round you will uniformly randomly choose a coin and a cardinal direction. You will move that coin 1 spot in that direction, if there is an empty space there. Or in other words, moves must satisfy the following rules:

  • The coins can only move up, down, left or right 1 spot.
  • Coins cannot move outside the board
  • Coins cannot overlap

This process should be repeated until every coin has moved into each spot on the board. You should output the state of the board after every move.

This is so shortest code in each language wins.

\$\endgroup\$
1
  • \$\begingroup\$ Still don't quite understand what is uniformly randomly choose here mean. For example, the board is OXO/XOX/OOO. If we first choose one coin, and then choose its direction, it will have 1/5 chance to chose the O in the middle. But if we list all possible moves and choose one from them, the middle one should have a 1/3 chance. \$\endgroup\$
    – tsh
    Feb 21 at 6:20
3
\$\begingroup\$

Draw an ASCII Volume

Posted here

\$\endgroup\$
3
\$\begingroup\$

Posted here

\$\endgroup\$
3
  • 2
    \$\begingroup\$ What is the order each rules applied? For example, for rules "11=12", "12=21", "22=3". If input is "1112", should it be "1112 -> 1212 -> 2121" or "1112 -> 1221 -> 131" or "1122 -> 1222 -> 123"? \$\endgroup\$
    – tsh
    Feb 22 at 7:58
  • \$\begingroup\$ All of them. See the original specification for Shue in the linked challenge, or the interpreter. \$\endgroup\$
    – Seggan
    Feb 22 at 15:11
  • \$\begingroup\$ As challenges should be self-contained, I suggest you add the mathematical definition from my post (and maybe an informal explanation of how the rules are applied non-deterministically) \$\endgroup\$
    – AnttiP
    Feb 22 at 16:46
3
\$\begingroup\$

Draw a Signal strength indicator

Posted here

\$\endgroup\$
3
\$\begingroup\$

Convert to UTF-∞

\$\endgroup\$
1
  • \$\begingroup\$ I believe if Unicode code points are used up. They are most probability caused by CJK characters. Until then, there are already >50% used code points represent CJK characters. And characters used by Chinese dialect other than Cantonese (HK source) are still missing in Unicode. \$\endgroup\$
    – tsh
    Feb 22 at 8:23
3
\$\begingroup\$

Ragged slice

Your task is to slice a ragged list. Your input is a ragged list and two lists of integers, corresponding to the beginning index and end index of the slice, where the beginning index is inclusive and the end index is exclusive.

Explanation

Let's start from the very basics. How does regular slicing work? Let's say we have the list [a,b,c,d,e,f] and we want the slice [1,4]. How does this work? Here is an illustration:

[a,b,c,d,e,f]
^ ^ ^ ^ ^ ^ ^
0 1 2 3 4 5 6
  v v v v
  [b,c,d]

This means that [a,b,c,d,e,f][1,4]==[b,c,d]. Ragged slicing is a bit tricky, so please make sure that the previous diagram is mostly clear. Ok, now ragged lists.

Let's first just draw the indices like previously for the list [a,[b,c],[d,[e]],f]:

[a, [b,c] , [d, [e] ] ,f]
^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^
0 1 1 1 1 2 2 2 2 2 2 3 4
    0 1 2   0 1 1 1 2
                0 1

Now, let's see what a slice of [1 1, 2 1 0] would look like:

[a, [b,c] , [d, [e] ] ,f]
^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^
0 1 1 1 1 2 2 2 2 2 2 3 4
    0 1 2   0 1 1 1 2
                0 1
      v v v v v v       
      ,c] , [d, [
       c] , [d
     [[c] , [d]]

The last steps are probably the most confusing. But basically we want to do two things, in the following order:

  1. Trim the left side until an element, or an opening bracket is encountered. Do the same on the right side, except with a closing bracket.
  2. Balance the remaining brackets and keep the depth of every array element the same as in the input, by wrapping the output in brackets.

Now, let's look at what happens when we have empty arrays. In fact, let's replace every letter in our previous example with an empty array:

[[] , [[] ,[] ] , [[] , [[] ] ] ,[] ]
^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^
0 0 1 1 1 1 1 1 2 2 2 2 2 2 2 2 3 3 4
  0   0 0 1 1 2   0 0 1 1 1 1 2   0
        0   0       0   0 0 1
                          0
          v v v v v v v v
          ,[] ] , [[] , [
           [] ] , [[]
         [[[] ] , [[]]]

Notice that for the empty array, the starting bracket doesn't have an index. This is because for an empty array, an index of 0 is already "one past the end" in an empty array, so there is no smaller index for the beginning.

If we would have used index 2 1 0 0 as the ending index, then this would have happened:

[[] , [[] ,[] ] , [[] , [[] ] ] ,[] ]
^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^
0 0 1 1 1 1 1 1 2 2 2 2 2 2 2 2 3 3 4
  0   0 0 1 1 2   0 0 1 1 1 1 2   0
        0   0       0   0 0 1
                          0
          v v v v v v v v v
          ,[] ] , [[] , [[]
           [] ] , [[] , [[]
         [[[] ] , [[] , [[]]]]

Lastly, let's see what happens if the slice is empty. We'll use [1 1 0, 2]:

[[] , [[] ,[] ] , [[] , [[] ] ] ,[] ]
^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^
0 0 1 1 1 1 1 1 2 2 2 2 2 2 2 2 3 3 4
  0   0 0 1 1 2   0 0 1 1 1 1 2   0
        0   0       0   0 0 1
                          0
            v v v
            ] ] ,

Here after step 1, the input just disappeared. We'll just return the empty list [].

Rules

Your input will contain only lists (no numbers, letters, etc.), and the starting and ending index. Indices can in bounds or one past the last in some array. Indices are non-empty lists of non-negative integers. The starting index is not greater than then ending index.

You can choose the order of the indices and also if they are 0 or 1 based (but they must be inclusive-exclusive).

This is so shortest code wins.

Meta

This is a bit tricky to explain. If there were parts that were unclear, or poorly written, etc. then please comment. If you think there is a better explanation, please also let me know.

\$\endgroup\$
4
  • \$\begingroup\$ I don't get why sometimes the opening bracket is indexed, and sometimes not. Could you explain? \$\endgroup\$
    – pajonk
    Feb 27 at 16:41
  • \$\begingroup\$ @pajonk I've added a paragraph explaining that. Basically it only happens for empty lists (that the starting bracket doesn't have an index). \$\endgroup\$
    – AnttiP
    Feb 27 at 16:57
  • \$\begingroup\$ Ok, that was a little confusing. Suggestion: replace empty lists with elements (like numbers) and disallow empty lists - wouldn't this be +/- equivalent and easier to explain? \$\endgroup\$
    – pajonk
    Feb 27 at 17:06
  • \$\begingroup\$ I would suggest simply index any elements and the ending of an array. So for example, Array [1, 2, 3] is indexed as [ 0=>1 1=>, 2 2=>, 3 3=> ]. And a slicing simply exclude the ending element. \$\endgroup\$
    – tsh
    Mar 1 at 7:56
3
\$\begingroup\$

Hello Shue! (Cops)

\$\endgroup\$
3
\$\begingroup\$

Circular chained compound

\$\endgroup\$
3
\$\begingroup\$

Draw the Ukrainian Flag

Draw the Ukrainian Flag

\$\endgroup\$
3
  • 1
    \$\begingroup\$ "horizontally down the middle" -> "horizontally across the middle" \$\endgroup\$
    – att
    Mar 18 at 21:54
  • \$\begingroup\$ @att oops, fixed \$\endgroup\$
    – Ginger
    Mar 18 at 21:57
  • \$\begingroup\$ Ginger u stole my challange idea :D (i thought it was too easy so i didnt post it) \$\endgroup\$
    – DialFrost
    Mar 19 at 0:23
3
\$\begingroup\$

Resolve a Super Auto Pets Round

\$\endgroup\$
3
\$\begingroup\$

Remove unmatched brackets

\$\endgroup\$
8
  • \$\begingroup\$ "containing of brackets"->"containing brackets"? Also, what characters to expect apart from brackets? You may also want to specify that we want to match the closest brackets together (inferred from example). And I think you lost first 543 in your example. \$\endgroup\$
    – pajonk
    Mar 17 at 19:51
  • \$\begingroup\$ @pajonk Fixed those. \$\endgroup\$
    – emanresu A
    Mar 17 at 20:19
  • \$\begingroup\$ What's with the 1 in the third testcase? \$\endgroup\$
    – ophact
    Mar 18 at 6:30
  • \$\begingroup\$ @ophact A typo. \$\endgroup\$
    – emanresu A
    Mar 18 at 7:44
  • \$\begingroup\$ "the input will only contain those and lowercase letters" - but the example string contains digits too! Could you remove them? \$\endgroup\$
    – pxeger
    Mar 23 at 6:39
  • \$\begingroup\$ @pxeger Oops... \$\endgroup\$
    – emanresu A
    Mar 23 at 8:28
  • 2
    \$\begingroup\$ I think it would be good to add a definition of "matched." It may not be immediately obvious to everyone who reads the challenge why [abc]def] should result in [abc]def and not [abcdef], since you could view either close bracket as being matched with the open bracket. \$\endgroup\$
    – DLosc
    Mar 23 at 14:06
  • \$\begingroup\$ @DLosc Done. (filler) \$\endgroup\$
    – emanresu A
    Mar 24 at 3:26
3
\$\begingroup\$

CGCC Rocket Biking

Something I found while looking through some old files. It seemed like a neat idea for a code golf challenge.

The intro

One of the most popular events at the annual Cyclist's Grand Competition for Charity (CGCC) is the rocket bike parcours. The rules are simple: Inspect the parcours and place a bet on wheather is it possible to reach the end with a speed of 0 m/s exactly. If those who said that it is possible can't prove it, the rest of the participants win, else the one to prove it wins.

The parcours

The rules for the parcours are as follows:

  • A parcours consists of uphills, downhills and flat bits.
  • The up-/downhills accelerate/decelerate the bike by 10 m/s.
  • On the flat bits the driver must either speed up or slow down manually, again, by 10 m/s. They mustn't do nothing.

The inspection

The participants don't know the parcours beforehand. They may only walk through it once before placing theirs bets and one other time to devise a strategy. The use of any form of map of the parcours is forbidden and leads to disqualification.

The task

We model the parcours as a sequence of /, \ and _ for the hilly bits and the flat bits. Given such a sequence as the input, output whether the parcours can be finished with a speed of 0 m/s at the finish line or not (validator). If yes, take the sequence again and output a sequence of + and - as an instruction for the driver on what to do on the flat bits (generator). The drivers start with a speed of 0 m/s.

The rules

  • This is , shortest answer wins.
  • Submit two programs that validate the parcours and generate the instructions for the driver if valid. Their length is added together for scoring.
  • The I/O format may be freely chosen, as long as it is not ambiguous.
  • The generator program only needs to work on valid parcours.
  • Each program may only read the input once and it may not save the input while reading.
  • The input length is not bounded.

The examples

Input: 
  \_///

Formatted for clarity:
      /
     /
  \_/

Validator output: 
  Falsy (The driver will come to a stop before the last uphill)
Input: 
  \_\__/

Formatted: 
  \_
    \__/

Validator output:
  Truthy

Generator output:
  --+
Input: 
  \_\_\

Formatted:
  \_
    \_
      \

Validator output: 
  Falsy (The driver will finish the parcours with at least 10 m/s)

The meta

  • Is anything unclear?
  • Should anything be changed to improve the qustion?
  • Do you have a better idea for the acronym pun? :)

If this gets enough upvotes to be posted, I'll add more and longer test cases.

\$\endgroup\$
5
  • \$\begingroup\$ Suggestion: Split it to two challenges (validating and generating instructions). \$\endgroup\$
    – pajonk
    Mar 27 at 18:00
  • \$\begingroup\$ Good challenge! Just one question: what does may not save the input while reading mean? Does "save" just mean saving to a file, or does it include variables too? In some languages, it would be impossible to do anything with input without saving it somewhere, even if not in an explicitly named variable. \$\endgroup\$ Mar 27 at 18:02
  • \$\begingroup\$ @pajonk That's a good idea, thanks! \$\endgroup\$ Mar 28 at 12:22
  • 1
    \$\begingroup\$ @SylvesterKruin I think the idea behind that could also be written as "The program may not work on more than one character of the input at any time.", i.e. reading the entire input bit-by-bit into a var and doing transformations on that isn't allowed. I used the wording from the file directly, which wasn't a good idea as it is rather lacking in other places too. \$\endgroup\$ Mar 28 at 12:23
  • 1
    \$\begingroup\$ this does seem like an interesting challenge! I do think the while thing about only reading the input once is A) confusing and mostly unnecessary, and B) kinda against the meta consensus against unobservable requirements. The code obviously takes a single text string in somehow, but what it does with that is not controllable. Also seconding the suggestion to split this into two challenges/get rid of one of them, as determining whether it is possible is a different matter from determining how to precisely stop at the end \$\endgroup\$
    – des54321
    Apr 3 at 1:08
3
\$\begingroup\$

Interpret +-=

\$\endgroup\$
9
  • \$\begingroup\$ I would say this is a fairly simple challenge, but it could still produce some interesting answers. However, it definitely needs some more clarification on input specifications. Should code read from a file? Prompt for input once and interpret that program? Prompt for an input, interpret that, and then repeat? \$\endgroup\$
    – des54321
    Mar 23 at 21:36
  • \$\begingroup\$ @des54321 prompt, interpret, repeat, as i think that has more golfing potential \$\endgroup\$ Mar 23 at 22:07
  • 1
    \$\begingroup\$ However I do realize that it won't exactly work on TIO... so idrk \$\endgroup\$ Mar 23 at 22:10
  • \$\begingroup\$ A few things I think you should specify : Is this code-golf or something else ? Can we assume input is always valid? Usually we do the task just once, it can be a full program or a function tacking arguments. \$\endgroup\$
    – AZTECCO
    Mar 24 at 12:17
  • \$\begingroup\$ @AZTECCO 1. this... is code-golf... are you ok? 2. Yes you can. \$\endgroup\$ Mar 24 at 21:13
  • \$\begingroup\$ Instead of explaining my suggestions in a comment I edited adding comments, feel free to reject anything you don't like. Hope it helps a bit.. Nice challenge btw! \$\endgroup\$
    – AZTECCO
    Mar 24 at 21:41
  • \$\begingroup\$ I would perhaps add a test case that results in negative output(s) (e.g. +=----= resulting in 1 -3) and perhaps one with multiple adjacent == (e.g. --== resulting in -2 -2). Apart from that I'd say it's good enough to be posted. And it may be simple, but it's good to have some simple challenges every now and then. :) In fact, I'd say it becomes harder and harder to come up with easy challenges suitable for beginners that aren't duplicates yet, so +1 from me. (I've already prepared a solution for when it goes to main.) \$\endgroup\$ Mar 28 at 15:31
  • \$\begingroup\$ @KevinCruijssen how about some of these? \$\endgroup\$ Mar 28 at 19:42
  • \$\begingroup\$ @BowlingPizzaBall Looks good. 👍 \$\endgroup\$ Mar 28 at 20:35
3
\$\begingroup\$

Convert angle to clock time

\$\endgroup\$
5
  • \$\begingroup\$ I strongly discourage strict output format restriction. Also, you may want to specify that only integer angles will be inputted (if that's the case). \$\endgroup\$
    – pajonk
    Apr 14 at 12:18
  • \$\begingroup\$ @pajonk Is it okay now? \$\endgroup\$
    – Yousername
    Apr 14 at 12:30
  • \$\begingroup\$ As long as identifiable as clock times by humans is also a list of hours and minutes and other reasonable formats - I'm fine with that :-) \$\endgroup\$
    – pajonk
    Apr 14 at 12:38
  • \$\begingroup\$ Outputting 0:00 instead of 12:00 is invalid, right? \$\endgroup\$
    – Steffan
    Apr 17 at 23:34
  • \$\begingroup\$ @Steffan Yes. The 12-hour time convention should be used. \$\endgroup\$
    – Yousername
    Apr 18 at 0:01
3
\$\begingroup\$

How normal is this group?

Let \$(G, *)\$ be some group. That is, for all \$x, y, z \in G\$, the following axioms hold:

  • \$x * y \in G\$
  • \$x * (y * z) = (x * y) * z\$
  • There exists some \$e \in G\$ such that \$x * e = e * x = x\$
  • There exists some \$x^{-1} \in G\$ such that \$x * x^{-1} = x^{-1} * x = e\$

For some group \$(G, *)\$, we define a subgroup of this as a group \$(H, *)\$ for some subset \$H \subseteq G\$. The trivial subgroups of a group \$(G, *)\$ are when \$H = \{e\}\$ (the identity element of \$G\$) and when \$H = G\$.

For the sake of convenience, we will denote \$x * y\$ as \$xy\$. Let \$N\$ be a subgroup of \$G\$. We say that \$N\$ is normal if, for all \$g \in G\$ and \$x \in N\$, \$gxg^{-1} \in N\$. For any group, the trivial subgroups are normal, and so any group has at least 2 normal subgroups.

For example, let \$G = \{0,1,2,3\}\$ and \$x * y = x + y \bmod 4\$. The subgroups of \$G\$ are \$\{0\}\$, \$\{0, 2\}\$ and \$\{0,1,2,3\}\$, all of which are normal. Therefore, \$(G, *)\$ has 3 normal subgroups.


Given a finite group, output a positive integer \$n \ge 2\$ counting the number of normal subgroups of the input. You may take a group as input in any reasonable manner, including but not limited to:

  • The set \$G\$ (as a set, list, etc.) along with a black-box function \$* : G \times G \to G\$
  • A square matrix representing the Cayley table of the group. You may choose whether to take \$G\$ as a separate input
  • A collection of triples \$(a, b, c)\$ where \$a, b, c \in G\$ and \$c = a * b\$ (the order of such a triple is irrelevant, but must be consistent for all triples)
  • etc.

This is a challenge, so the shortest code in bytes in each language wins.


Test cases

G
∗ : G×G → G
output

{0,1,2,3}
a*b = a+b mod 4
3
\$\endgroup\$
1
  • \$\begingroup\$ You may want to define a subgroup: a group defined by the same operation \$ * \$ as \$ G \$, with elements which are a strict subset of \$ G \$. \$\endgroup\$
    – pxeger
    Apr 12 at 8:29
3
\$\begingroup\$

King of the Cards

\$\endgroup\$
1
  • \$\begingroup\$ This seems like it won't be particularly strategic \$\endgroup\$ May 9 at 18:01
3
\$\begingroup\$
\$\endgroup\$
0
3
\$\begingroup\$

Whyte Notation Translator

\$\endgroup\$
7
  • 1
    \$\begingroup\$ I think the scoring is sufficiently punishing to answers missing any cases that none will be able to make use of that in interesting ways. \$\endgroup\$ May 16 at 19:25
  • \$\begingroup\$ @RadvylfPrograms That's true, i guess i could change that to a multiplication instead. How about S = codesizefunc1 * (1+u) + codesizefunc2 * (1+v) ? Or maybe using the square root on u and v ? \$\endgroup\$ May 16 at 19:27
  • \$\begingroup\$ Those might work too, but then you run into the risk of people optimizing the combination of code size and cases handled, and getting something boring like x=>"AA20". I think it'd be better to just use the sum of the code sizes as the score. Since it seems like parsing the os into indices into a list is probably going to be how most solutions work, and that's the interesting part of the challenge (since the outputs can't really be compressed), you might even consider allowing a third program that provides the list of names, that's weighted to count for less. \$\endgroup\$ May 16 at 19:39
  • \$\begingroup\$ @RadvylfPrograms What would be the purpose of the third program and the reduced weight of it ? \$\endgroup\$ May 18 at 10:27
  • \$\begingroup\$ Since there's no interesting way to compress the list of names \$\endgroup\$ May 18 at 13:28
  • 1
    \$\begingroup\$ Prairie and Adriatic are both mapped to oOOOo. \$\endgroup\$
    – Arnauld
    May 28 at 20:34
  • \$\begingroup\$ @Arnauld You're right, it's corrected and posted \$\endgroup\$ May 29 at 17:13
3
\$\begingroup\$

Tell me how many there are, in Polish

Today, you're going to be writing Polish. No, not Polish notation—Polish, the actual language spoken in Poland.

Given a number and a noun, output a Polish sentence telling me that there are that many of that thing, using the appropriate template below.

The input consists of an integer in the range from 0 to 200, and a string of 1 to 10 lowercase ASCII letters (called the "noun"). You may accept these inputs in any reasonable format.

The output must consist of one of the below output templates, where the number in the template (if any) has been replaced with the input integer, and the word kot in the template has been replaced with the input noun.

Output templates

If the input number is 0, then use the output template

Nie ma żadnych kotów.

If the input number is 1, then use the output template

Jest 1 kot.

If the input number ends with 2, 3, or 4, but does not end with 12, 13, or 14, then use the output template

Są 4 koty.

In any other case, use the output template

Jest 8 kotów.

Note that the special characters used in these templates are:

  • ż (in "żadnych") – U+017C Latin small letter Z with dot above
  • ó (in the suffix "-ów") – U+00F3 Latin small letter O with acute
  • ą (in "Są") – U+0105 Latin small letter A with ogonek

You may output these characters in any reasonably common character encoding (including HTML entities), and you may use combining characters instead of precomposed characters (or even a mixture of the two).

Test cases

0 pomidor -> Nie ma żadnych pomidorów.
1 kwiat -> Jest 1 kwiat.
2 dom -> Są 2 domy.
5 wilk -> Jest 5 wilków.
13 komputer -> Jest 13 komputerów.
24 but -> Są 24 buty.
101 kurczak -> Jest 101 kurczaków.

Do plurals in Polish really work that way?

No, the way it actually works is much more complicated.

This is , so the shortest program in each language wins.

\$\endgroup\$
1
  • 1
    \$\begingroup\$ Suggested test-cases with 3-digit numbers ending with 02-04, 12-14, x2-x4 (with x>1) and outside those ranges (>101). \$\endgroup\$
    – pajonk
    Jun 3 at 8:11
3
\$\begingroup\$

Find the winning Mormon Bridge card

Mormon Bridge (also called Oh Heck, similar to Oh H***) is a card game played (at least by me) with a standard Rook deck. A standard Rook deck includes cards 1-14 in 4 suits, which are black, red, green, and yellow, and a Rook card. Each round, a card is taken from the deck. It's suit is chosen as "trump." Then, players take turns playing cards. We'll call the suit of the first players card "sub-trump". If the Rook card is played, it wins. If trump was played, the highest trump card wins. Otherwise, the highest sub-trump card wins.

Your Goal

Your goal is to take input for:

  • Trump
  • Sub-trump
  • Cards played

and output the winning card. You may take input in any reasonable manner, swapping suit colors for numbers is fine, as is taking input for all cards played in order instead of separating the first card. , so shortest answer in bytes wins.

Test cases

(note that input can be taken in any reasonable format, these are written in a human-readable format.)

Trump: Red
Cards played: Red 4, Rook, Black 14, Yellow 7
Output: Rook

Trump: Green
Cards played: Red 14, Red 8, Green 2, Yellow 6
Output: Green 2

Trump: Yellow
Cards played: Red 5, Green 7, Red 12, Black 6
Output: Red 12

Meta

What tags should be on this? Are the rules clear enough?

\$\endgroup\$
2
  • 1
    \$\begingroup\$ I think the rules are pretty clear. It would be great if you could add some examples of input => expected output \$\endgroup\$ Jun 7 at 21:14
  • 1
    \$\begingroup\$ @mathjunkie added test cases \$\endgroup\$
    – 00Her0
    Jun 8 at 1:05
3
\$\begingroup\$

Is it a valid list?

\$\endgroup\$
6
  • 1
    \$\begingroup\$ Suggestion: allow input also with {} or (), maybe even allow separators to be spaces or semicolons. \$\endgroup\$
    – pajonk
    Jun 12 at 5:28
  • 1
    \$\begingroup\$ "Outputting by erroring/not erroring is not allowed" - I presume this is to prevent people from submitting solutions which are just eval. This tends not be a good approach, and I think solutions like eval are still interesting. Maybe instead you could ask that people post solutions which don't directly do any parsing into one Community Wiki answer, like is sometimes done for builtin answers to catalogue-style questions. [contd...] \$\endgroup\$
    – pxeger
    Jun 12 at 9:18
  • 1
    \$\begingroup\$ @pxeger Good idea :P \$\endgroup\$
    – emanresu A
    Jun 12 at 9:19
  • 1
    \$\begingroup\$ [...contd] But I think disallowing error output is not the right way to go about it, because (1) people will still post them, but wrapped in a try-catch or whatever, which is a no more interesting answer; and (2) people can write interesting answers which don't use eval, but which can be shorter using error output as a kind of "short-circuiting" output mechanism. \$\endgroup\$
    – pxeger
    Jun 12 at 9:20
  • \$\begingroup\$ Suggested falsey test-case: [[]][[]], which may erroneously be accepted by eval-like solutions \$\endgroup\$
    – pxeger
    Jun 12 at 12:22
  • \$\begingroup\$ @pxeger Added.. \$\endgroup\$
    – emanresu A
    Jun 12 at 19:46
3
\$\begingroup\$

backwardS_hybriD-snakE_kebaB-cameL_case

\$\endgroup\$
0
3
\$\begingroup\$

Fix my FizzBuzz

\$\endgroup\$
2
  • \$\begingroup\$ You need some more test cases, to cover: inputs that are already valid and don't need shuffling, inputs with only numbers, inputs with no numbers, inputs with FizzBuzz in them. \$\endgroup\$
    – pxeger
    Jun 26 at 16:40
  • \$\begingroup\$ @pxeger Done. (filler) \$\endgroup\$
    – emanresu A
    Jun 26 at 19:47
3
\$\begingroup\$

Which R version is it? It's Peanuts!

\$\endgroup\$
4
  • \$\begingroup\$ Related \$\endgroup\$
    – Arnauld
    Jun 29 at 15:51
  • \$\begingroup\$ I'm pretty sure there's some other challenge more closely related to this one. But I personally don't care as I love this kind of challenges anyway. ;) \$\endgroup\$
    – Arnauld
    Jun 29 at 15:52
  • \$\begingroup\$ Ah, here it is: related \$\endgroup\$
    – Arnauld
    Jun 29 at 16:00
  • \$\begingroup\$ @Arnauld thanks! I hope it won't be considered a duplicate... \$\endgroup\$
    – pajonk
    Jun 29 at 18:26
3
\$\begingroup\$

Simplify Rubik's Cube Moves

\$\endgroup\$
1
19 20
21
22 23
133

You must log in to answer this question.

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