541
\$\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 needs more feedback, but it's been ignored, you can ask for feedback in The Nineteenth Byte. It's not only allowed, but highly recommended!

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

3624 Answers 3624

1
15 16
17
18 19
121
3
\$\begingroup\$

cadaddadadaddddaddddddr - linked list accessing

\$\endgroup\$
8
  • \$\begingroup\$ Yay, a lisp challenge! Does each 'a' mean a car and each 'd' a cdr? \$\endgroup\$
    – user
    Mar 24 '21 at 21:56
  • 1
    \$\begingroup\$ @OriginalOriginalOriginalVI yeah, but I'm to lazy to have written a description in english so far. I guess I'll get to it eventually :P \$\endgroup\$ Mar 24 '21 at 21:58
  • \$\begingroup\$ Fortunately the common lisp hyperspec already describes the bulk of it well. \$\endgroup\$ Mar 24 '21 at 22:22
  • \$\begingroup\$ You might want to make the reference implementation a link to TIO (unless it doesn't work on TIO, of course) \$\endgroup\$
    – user
    Mar 24 '21 at 22:23
  • \$\begingroup\$ @OriginalOriginalOriginalVI Why? (I can't access TIO anyway) \$\endgroup\$ Mar 24 '21 at 22:25
  • \$\begingroup\$ Meh, I just don't like those code snippets, and it makes it easier to pull out of the question, modify the input, and stuff. These code snippets sometimes break for me. If you can't access TIO, though, it doesn't matter, of course. \$\endgroup\$
    – user
    Mar 24 '21 at 22:26
  • \$\begingroup\$ posted \$\endgroup\$ Mar 25 '21 at 15:04
  • \$\begingroup\$ I've edited this down to a stub now that it's been posted \$\endgroup\$ Mar 28 '21 at 14:01
3
\$\begingroup\$

Un-pipe an Elixir expression

\$\endgroup\$
5
  • \$\begingroup\$ It's unclear what kind of expressions we have to deal with, but it looks good, and interesting . E.g. do we have to handle expr |> function(with_one_parameter)? \$\endgroup\$ Mar 25 '21 at 15:27
  • \$\begingroup\$ @Wezl I was thinking the expression could be anything with printable non-whitespace ASCII but I realize now that could be problematic. I'll change it to be more restrictive. \$\endgroup\$
    – 79037662
    Mar 25 '21 at 15:30
  • \$\begingroup\$ @Wezl I specified that you may assume all functions will take only one parameter, so you do not have to handle expr |> function(with_one_parameter). \$\endgroup\$
    – 79037662
    Mar 25 '21 at 15:39
  • 1
    \$\begingroup\$ Why do some piped expressions have () and some do not? Are we meant to support both of these? \$\endgroup\$
    – emanresu A
    Mar 26 '21 at 4:45
  • \$\begingroup\$ @Ausername It's to demonstrate that both are valid, but as I state in the rules you need only support one convention. \$\endgroup\$
    – 79037662
    Mar 26 '21 at 13:17
3
\$\begingroup\$

What's my TIO uniqueness?

\$\endgroup\$
9
  • \$\begingroup\$ Oops, didn't read that \$\endgroup\$
    – user
    Mar 23 '21 at 20:59
  • \$\begingroup\$ Maybe you could say "undefined" instead of 0 in the sentence "The TIO uniqueness of a language for which this is impossible is 0". Also, do you want submissions to store all 680 language names in the code? \$\endgroup\$
    – Bubbler
    Mar 24 '21 at 23:58
  • 1
    \$\begingroup\$ @Bubbler Changed to undefined, it fits better. Yes, submissions should have some way of storing the names, be it in an external file or in the program itself etc. \$\endgroup\$ Mar 25 '21 at 0:02
  • \$\begingroup\$ @FryAmTheEggman Given that there are 680, I think it may be impractical to include the full list in the question, which is why I linked to this gist with all languages and their outputs \$\endgroup\$ Mar 25 '21 at 0:20
  • \$\begingroup\$ Ah, sorry, I missed the link. \$\endgroup\$ Mar 25 '21 at 3:44
  • \$\begingroup\$ "subsequence" tag? Why? \$\endgroup\$
    – tsh
    Mar 29 '21 at 8:58
  • 1
    \$\begingroup\$ @tsh Because the TIO uniqueness depends on the shortest substring that isn't common with any other language \$\endgroup\$ Mar 29 '21 at 18:49
  • \$\begingroup\$ but substring is not subsequence \$\endgroup\$
    – tsh
    Mar 30 '21 at 0:32
  • \$\begingroup\$ @tsh No, but [substring] isn't a tag, and [subsequence] is the best alternative \$\endgroup\$ Mar 30 '21 at 21:37
3
\$\begingroup\$

Rejecting invalid IPv4 addresses

\$\endgroup\$
4
  • \$\begingroup\$ You should generally include the definition of things like this directly in the challenge rather than just linking to a Wikipedia article on it, so people don't have to go to an external site \$\endgroup\$
    – pxeger
    Apr 8 '21 at 8:42
  • \$\begingroup\$ I think it would be clearer if you used boolean true/false for "is this valid", rather than "invalid" vs "valid". You might also want to change classification to decision-problem \$\endgroup\$
    – pxeger
    Apr 8 '21 at 8:46
  • \$\begingroup\$ @pxeger Thanks. Included both suggestions. \$\endgroup\$
    – rsjaffe
    Apr 8 '21 at 15:55
  • \$\begingroup\$ Is this means the input should always be a string / list of characters? May I take input as an array of 4 integers / a 32 bit unsigned integer / a built-in type for IP address (if there is one)? \$\endgroup\$
    – tsh
    Apr 13 '21 at 3:57
3
\$\begingroup\$

Interpret control characters like a terminal

\$\endgroup\$
4
  • \$\begingroup\$ As "your program does not need to interpret backslash escape sequences - the input will contain the literal control codes themselves.", I'd suggest actually including the characters in the test cases, or at least including a TIO link (or pastebin etc.) with the literal characters \$\endgroup\$ Apr 12 '21 at 13:14
  • 1
    \$\begingroup\$ @cairdcoinheringaahing \r isn't really usable on the web because it will be converted to a newline, and most languages have their own literal syntax for entering those characters anyway, so I think it wouldn't really help \$\endgroup\$
    – pxeger
    Apr 12 '21 at 13:18
  • 1
    \$\begingroup\$ Suggest a aaaaaaa\b\b\b\t case, do TAB fill them space? \$\endgroup\$
    – l4m2
    Apr 15 '21 at 4:17
  • \$\begingroup\$ @l4m2 thanks - that helped me discover some subtle bugs in my reference implementation too \$\endgroup\$
    – pxeger
    Apr 15 '21 at 9:01
3
\$\begingroup\$

You are kinda Replacable to Me

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

A Self-Referential Sentence

The Story


One day, you decide that you want a sentence that tells you where in the sentence the letter T occurs (excluding whitespace and punctuation). Out of curiosity, you try to make one. Messing around a little you get

T is the first, fourth, eleventh, sixteenth, twenty-fourth, ....

Oh dear, this sentence appears to run forever. But you now think you have an interesting number sequence, so you slap it into the OEIS search bar and lo and behold you find sequence A005224, Aronson's sequence. And better yet, an interesting code-golf problem that no appears to have posed before!


The Task

Your task is to write a program that takes in a single positive integer, n, as input and gives the position of the n-th "t" in the above sentence (indexing begins at 1 for the sake of this problem). For example, an input of 1 should return 1, while 2 should return 4. The input number will not exceed 4 decimal digits in length (i.e. the maximum input is 9999)

As always, the shortest code in bytes wins, and standard loopholes apply.


Tags:


The Meta

Ok, so I have a couple of questions, since this my first sandbox post.

  1. What can I do to flesh out this problem? This seems short, especially for a CGSE prompt. Should I somehow flesh out the heading fluff? Or should I add something more to the task itself?
  2. I was pretty thorough in my search of the sandbox and main site for similar problems, but I could always have missed something, so please let me know if this is a duplicate.
  3. Is the 4 digit input limit reasonable? Should I raise it or lower it? Remove it entirely? Since I'm not providing a file with ordinal strings, it seems like having a restriction on the size of the input is quite important.
  4. Finally, please let me know if there's any other glaring problems in this prompt, this is both a first draft, and my first attempt at a code-golf prompt (since high-school).
\$\endgroup\$
3
  • \$\begingroup\$ Nice first challenge! I'd suggest following the standard sequence I/O rules and allowing programs to output either the first \$n\$, the \$n\$th term or all terms. Additionally, forcing 1-indexing (for the sequence) doesn't improve the challenge any more than allowing either 0 or 1 indexing. I cannot find any challenge that could be a dupe through some searching, so this looks to be 100% original. Finally, I'd recommend including either test cases or the first 10 or so terms in the challenge body \$\endgroup\$ Apr 24 '21 at 16:21
  • 1
    \$\begingroup\$ @cairdcoinheringaahing 1-indexing is fundamental to the recursive definition of this sequence, as “T is the zeroth, third, tenth, twelfth, seventeenth, twentieth, …” is quite a different sequence (not just off by one). \$\endgroup\$ Apr 25 '21 at 18:25
  • \$\begingroup\$ @AndersKaseorg I meant 0 indexing in the input, not in the position of the T (e.g. n = 0 would output 1, n = 1 would output 4, etc.) \$\endgroup\$ Apr 25 '21 at 18:27
3
\$\begingroup\$

diddly darn posted

\$\endgroup\$
10
  • \$\begingroup\$ Tag chess? \$\endgroup\$
    – pxeger
    Apr 12 '21 at 6:43
  • 1
    \$\begingroup\$ My god, this is amazing. I can't wait to see the full version! \$\endgroup\$ Apr 12 '21 at 9:48
  • 1
    \$\begingroup\$ It's not clear to me what should be output in the non-deterministic cases. Do we have to output all possibilites? \$\endgroup\$
    – kops
    Apr 22 '21 at 23:35
  • \$\begingroup\$ Addtionally, what do you want the result of this to be: ,v, \n >,A \n ^<B (pastebin; is multline code possible in a comment?) Rules as written I think it's a tie since the center cell is reached twice but it's not clear this is desirable. \$\endgroup\$
    – kops
    Apr 22 '21 at 23:37
  • \$\begingroup\$ @kops it's okay for the board to result in a tie. \$\endgroup\$
    – lyxal
    Apr 22 '21 at 23:43
  • \$\begingroup\$ And the point is to output the result of the board, which may not be deterministic \$\endgroup\$
    – lyxal
    Apr 22 '21 at 23:43
  • \$\begingroup\$ So each possibility has to be output with the correct probability in the non-deterministic cases? And for the specific board in my second comment, it's very much morally an A victory, not a tie, but the technicality of passing through the same cell going in different directions makes it a tie in these rules which I find a bit weird. \$\endgroup\$
    – kops
    Apr 22 '21 at 23:46
  • \$\begingroup\$ @kops no it is not the probability but the result of running it once. That result may vary. And even though that may seem like it should be a win for A, it could be the result of some clever play from B to trick A into thinking they've won \$\endgroup\$
    – lyxal
    Apr 22 '21 at 23:50
  • \$\begingroup\$ @Lyxal I didn't mean to say the probability itself should be output, but that for each possibility, the probability of that possibility being output has to be correct? \$\endgroup\$
    – kops
    Apr 22 '21 at 23:56
  • \$\begingroup\$ @kops you only ever output one result - the winner of the game when evaluated. Because there are commands that change the direction, it can be impossible to 100% tell who wins. I was simply pointing out that there is more than one possible output for such boards. \$\endgroup\$
    – lyxal
    Apr 22 '21 at 23:59
3
\$\begingroup\$

Interpret Gelatin

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

CDGLF:TMN2APL


Meta questions:

  • Is this a duplicate? (I've looked and there are several challenges with operator precedence, but there are large differences such as floor/ceiling and the output format)
  • How can I objectively define "equivalent expressions"? Should I write a reference interpreter or answer?
  • Would it be more interesting going the other way?
  • Should answers be required to reject invalid input? Seems not
  • Should I I've replaced the unicode operators ×÷⌈⌉⌊⌋ with ascii symbols */{}[].
  • Is the exponentiation operator necessary? (It might just make the challenge more cumbersome because of its different associativity)
\$\endgroup\$
6
  • \$\begingroup\$ It was previously APL2TMN. I'm changing it to TMN2APL to make it more interesting. \$\endgroup\$ Apr 22 '21 at 14:42
  • 1
    \$\begingroup\$ TMN's +-×÷ are left-associative, but in APL everything is right-associative. The equivalent of TMN 3-5÷2+1 in APL is (3-5÷2)+1; APL 3-(5÷2)+1 is 3-((5÷2)+1). \$\endgroup\$
    – Bubbler
    Apr 22 '21 at 23:41
  • 1
    \$\begingroup\$ Thanks, I completely forgot about associativity. I don't think my grammar handles it, however, so I'm not sure exactly how to resolve this. \$\endgroup\$ Apr 22 '21 at 23:44
  • 1
    \$\begingroup\$ Also, I suggest to state the output format (APL) in the same way as you did for the input format (TMN), and state the precedence and associativity (for both TMN and APL) separately in plain English for those who are not familiar with parser grammars. And I think input validation is unnecessary here. \$\endgroup\$
    – Bubbler
    Apr 22 '21 at 23:52
  • \$\begingroup\$ I think the Unicode operators definitely should be replaced with ASCII, because otherwise it's 10 bytes used on every answer. This would require you to remove or change the output syntax of exponentiation, but I don't really feel like it adds much tbh. \$\endgroup\$
    – pxeger
    Apr 24 '21 at 15:57
  • 1
    \$\begingroup\$ @pxeger I've changed it, and I agree. \$\endgroup\$ Apr 25 '21 at 0:53
3
\$\begingroup\$

Distance between vowels

Objective

Given two vowels represented in single IPA characters, calculate the distance between them.

Vowels

Vowels are characterized by three factors: Height, backness, and roundedness. Here, all vowels have the three characteristics as integers.

Unrounded vowels (z = 0)

    x=0       x=1       x=2       x=3       x=4
y=6 i(U+0069)           ɨ(U+0268)           ɯ(U+026F)
y=5           ɪ(U+026A)           ʊ(U+028A)
y=4 e(U+0065)           ɘ(U+0258)           ɤ(U+0264)
y=3                     ə(U+0259)
y=2 ɛ(U+025B)           ɜ(U+025C)           ʌ(U+028C) 
y=1 æ(U+00E6)           ɐ(U+0250)
y=0 a(U+0061)                               ɑ(U+0251)

(I know, Wikipedia states ʊ as rounded, but official IPA doesn't specify the roundedness of ʊ. It will be considered unrounded for this challenge.)

Rounded vowels (z = 1)

    x=0       x=1       x=2       x=3       x=4
y=6 y(U+0079)           ʉ(U+0289)           u(U+0075)
y=5           ʏ(U+028F)
y=4 ø(U+00F8)           ɵ(U+0275)           o(U+006F)
y=3
y=2 œ(U+0153)           ɞ(U+025E)           ɔ(U+0254) 
y=1
y=0 ɶ(U+0276)                               ɒ(U+0252)

Metric

Your metric \$d\$ shall fit the usual definition of metric:

  • \$d(v,w)=0\$ if and only if \$v=w\$

  • For all \$v\$ and \$w\$, \$d(v,w)=d(w,v)\$

  • For all \$v\$, \$w\$ and \$x\$, \$d(v,x)≤d(v,w)+d(w,x)\$

As an additional constraint, the norm \$\Vert\cdot\Vert\$ induced by \$d\$ shall satisfy:

  • For all \$x≠0\$, \$y\$ and \$z\$, \$\Vert(0,y,z)\Vert<\Vert(x,y,z)\Vert\$

  • For all \$x≠0\$, \$y\$, \$z\$ and \$k>1\$, \$\Vert(x,y,z)\Vert<\Vert(kx,y,z)\Vert\$

  • Analogous rules for the y-axis and z-axis

All of these apply only to the vowels above. All other inputs fall in don't care situation.

Rules

  • Input format is flexible. It may be two chararacters, or a single string containing two charcters. In any case, every input that doesn't fit in your format falls in don't care situation.

  • Output format is also flexible.

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

Generate a UK number plate

\$\endgroup\$
5
  • \$\begingroup\$ I'd suggest saying AANNXXX or something like that instead of AA12XXX so it's clear the age identifier isn't always 12 (that's clarified later, but still). \$\endgroup\$
    – user
    Apr 28 '21 at 18:12
  • \$\begingroup\$ Just a note: the last 3 characters can't be either Q or I \$\endgroup\$ May 1 '21 at 18:13
  • \$\begingroup\$ @cairdcoinheringaahing I thought that too, but I found no mention of it in the government document so I kept it as the whole alphabet. shrug \$\endgroup\$
    – pxeger
    May 1 '21 at 19:37
  • \$\begingroup\$ There's a Q in the alphabet for the first letter, but then you say the alphabet, minus IJQTUXZ. \$\endgroup\$
    – Arnauld
    May 5 '21 at 18:13
  • 1
    \$\begingroup\$ @Arnauld yep, that shouldn't be there. Too much muscle memory from typing the alphabet correctly I guess :þ \$\endgroup\$
    – pxeger
    May 5 '21 at 19:15
3
\$\begingroup\$

I'm Lazy: Close my Parens

\$\endgroup\$
10
  • 1
    \$\begingroup\$ It's clear what to do with ], but what does [ represent? Is it the same as just (? \$\endgroup\$
    – DJMcMayhem
    Jun 1 '21 at 22:00
  • \$\begingroup\$ Why is ([(] invalid but [(] is not? Will there ever be multiple ] in a row? \$\endgroup\$
    – DJMcMayhem
    Jun 1 '21 at 22:05
  • \$\begingroup\$ @DJMcMayhem ([(] is invalid because it is the same as [(] but with an unmatched ( at the beginning since the ] only closes the [. There may be multiple ] in a row. \$\endgroup\$ Jun 1 '21 at 22:08
  • 3
    \$\begingroup\$ So basically ] matches as many open parens as possible until it hits a [ at which point it has to stop? \$\endgroup\$
    – DJMcMayhem
    Jun 1 '21 at 22:10
  • \$\begingroup\$ @DJMcMayhem yes. Should I add that to the question for clarity? \$\endgroup\$ Jun 1 '21 at 22:12
  • \$\begingroup\$ Yes, I think that would help. \$\endgroup\$
    – DJMcMayhem
    Jun 1 '21 at 22:17
  • 1
    \$\begingroup\$ Not sure if lisp tag is appropriate, because the challenge itself doesn't have to do with lisp. \$\endgroup\$
    – qwr
    Jun 2 '21 at 14:43
  • 2
    \$\begingroup\$ Tag: balanced-string? \$\endgroup\$
    – pxeger
    Jun 3 '21 at 10:47
  • \$\begingroup\$ @pxeger nice tag-finding skills :) I'll add that. \$\endgroup\$ Jun 3 '21 at 13:04
  • \$\begingroup\$ @qwr How else do I get the tag badge :P \$\endgroup\$ Jun 3 '21 at 13:07
3
\$\begingroup\$

But, Is It Art?

\$\endgroup\$
1
  • \$\begingroup\$ I think it is clear, but the second example of "is not equivalent to" is a little unnecessary in my opinion. \$\endgroup\$
    – Alex bries
    Jun 2 '21 at 10:03
3
\$\begingroup\$

Generalised multi-dimensional chess knight's moves

Posted

\$\endgroup\$
2
  • \$\begingroup\$ You know that the necessary conclusion is we do all the pieces - take my +1 and start the chain. \$\endgroup\$ Jun 14 '21 at 6:26
  • 1
    \$\begingroup\$ @StackMeter I don't think most of the pieces would be very interesting. Pawns in combination with details of what pieces are already on the board, maybe. Otherwise, it's just this challenge with some slightly simpler vectors \$\endgroup\$
    – pxeger
    Jun 14 '21 at 6:48
3
\$\begingroup\$

Write a C++ demangler

\$\endgroup\$
6
  • \$\begingroup\$ Is _ZN3foo3barE3baz -> foo(bar)::baz valid? \$\endgroup\$
    – tsh
    Jun 7 '21 at 8:39
  • \$\begingroup\$ That would be foo::bar::baz. The base identifier is baz, and it is prefixed with the namespace foo::bar. \$\endgroup\$
    – EasyasPi
    Jun 7 '21 at 14:27
  • \$\begingroup\$ Won't foo::bar::baz be _ZN3fooEN3barE3baz or _ZNN3fooE3barEbaz? \$\endgroup\$
    – tsh
    Jun 8 '21 at 6:14
  • \$\begingroup\$ No, nested namespaces are placed together without a separator. \$\endgroup\$
    – EasyasPi
    Jun 8 '21 at 12:39
  • \$\begingroup\$ Decided to remove the "if it doesn't start with _Z, then it is to be printed as-is" as that adds unnecessary complexity. \$\endgroup\$
    – EasyasPi
    Jun 13 '21 at 23:55
  • 3
    \$\begingroup\$ I've edited this down to a stub now that it's been posted to save space \$\endgroup\$ Jun 17 '21 at 20:30
3
\$\begingroup\$

Create word lightning

Posted

\$\endgroup\$
2
  • \$\begingroup\$ Trees can be taken in different formats, right? \$\endgroup\$ May 14 '21 at 13:35
  • \$\begingroup\$ yes, they can be taken in any suitable format. \$\endgroup\$
    – Razetime
    May 14 '21 at 13:47
3
\$\begingroup\$

Jump trajectory

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

Reconstruct a recursively prime-encoded integer

\$\endgroup\$
1
  • \$\begingroup\$ Looks great! At first glance seems easy but it's actually a little more difficult. I think it's ready to post, although you might want to wait a day or so. \$\endgroup\$
    – user100690
    Jun 20 '21 at 12:14
3
\$\begingroup\$

Splinter metagolf

\$\endgroup\$
2
  • \$\begingroup\$ An example for a short repetitive string would be nice \$\endgroup\$
    – pxeger
    Jul 12 '21 at 9:42
  • \$\begingroup\$ @pxeger Ok, I'll have a look. \$\endgroup\$
    – emanresu A
    Jul 12 '21 at 9:43
3
\$\begingroup\$

Which character to change (Cops)

Which character to change (Robbers)

\$\endgroup\$
2
  • \$\begingroup\$ I think cops should definitely be able to choose what strings they print (they obviously should reveal them to the robbers) \$\endgroup\$
    – pxeger
    Jul 13 '21 at 8:30
  • \$\begingroup\$ @pxeger that's a good idea \$\endgroup\$
    – mathcat
    Jul 14 '21 at 13:45
3
\$\begingroup\$

Posted! - How many Sets are there?

\$\endgroup\$
2
  • \$\begingroup\$ Minor suggestion: Move the expected outputs to the start, because you have to scroll all the way to the end to see them. \$\endgroup\$
    – user
    Jul 19 '21 at 23:59
  • \$\begingroup\$ @user Done, thanks. \$\endgroup\$ Jul 21 '21 at 4:36
3
\$\begingroup\$

Visual Encoding

I want to create a program to randomize certain words, however, I would like all the swapped letters to have the same form factor as the previous one.

Challenge

Given a string of only lowercase letters (and no spaces), randomize its letters according to the following groups:

1: acemnorsuvwxz
2: bdfhiklt
3: gpqy

Each letter cannot be transformed into the same letter as it started as. Additionally, choosing the new character must be uniformly random (within codegolf guidelines).

One final thing is that for the letter j, it must be transformed into either group 2 or group 3, and this can be done by either:

Uniformly choosing between each group and then uniformly choosing a letter or Uniformly choosing between any of the letters in both groups

Note that nothing can turn into j itself.

Examples

helloworld -> kadfrszmhl
jamaica -> genokac
jamaica -> penokac
abpj -> odyt

This is so the goal is to create the shortest answer in bytes.

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

Find the necessary Files

Let's assume you have program that needs some of the files in a given folder to run. But not all the files in this folder are actually necessary. You can only find out which are necessary be removing/adding files from/to that folder, running the program and then observing whether it runs or throws or fails. The goal is finding exactly the necessary set of files with the minimial number of calls to the program.

Let's formalize it a little bit:

You are given a black-box-function \$ f: \{0,1\}^n \to \{0,1\} \$ that is of the form \$f(x_1, \dots, x_n) = \prod_{i \in I} x_i\$ where \$I\subseteq \{1,2,3,\ldots,n\}\$.

Your goal is finding \$I\$.

Your program may only interact with \$f\$ by evaluating it at various \$x \in \{0,1\}^n\$.

Your score is \$ S= \prod_{m=1}^M (1+s_k)\$ where \$s_k\$ is the number of evaluations of \$f\$ you needed for the example \$k\$ in the test battery. The least score wins.

Test Battery

META: Not sure yet if I should explicitly define a test battery or just let participants iterate through all possible functions up to some \$n\$.

In the following list, the first column represents \$n\$ (the number of arguments) followed by the set \$I\$:

n  | I
3  | 1
3  | 1 3
3  | 1 2 3
4  | 2 3 4
10 | 1 3 5 6 7 9

The last entry for instance represents the function \$ f(x_1, x_2, \ldots x_{10}) = x_1 \cdot x_3 \cdot x_5 \cdot x_6 \cdot x_7 \cdot x_9\$

\$\endgroup\$
1
  • \$\begingroup\$ Could the title have the "files" removed to be more abstract (or use another analogy)? On the surface this might look like a filesystem question \$\endgroup\$
    – pxeger
    Aug 10 '21 at 11:05
3
\$\begingroup\$

Parse some Husk (WIP)

Husk is a "functional golfing language inspired by Haskell." Its syntax is prefix, albeit with a twist: Husk's functions can be curried: so uses its static typing to determine how many arguments a function should take at a time. For example, Husk can tell that m+2:2;3 should be parsed as m(+2)(:2(;3)) and not, say, m(+2(:2(;3))) or m(+)(2:2;3), which are meaningless.

Task

This challenge involves validating a subset of Husk that has 5 functions and two types: integers 0-9 or lists of those integers. It also does not have parentheses or overloading. Your submission will take a string consisting only of the characters mo;:+0123456789 and determine whether it is a valid program according to the rules below.

In the following descriptions, "unary integer function" refers to a function that takes an integer and outputs another. It's a made-up term, let me know if there's a better one. "list" refers to a list of integers, and "integer" refers to an integer 0-9. You don't need to understand the purposes of each function, just the types of their inputs and outputs.

  • 0-9 are values/integers.
  • ; is the unary function singleton. Its argument is an integer x, and it returns a list ([x]).
  • : is the binary function prepend. Its first argument is an integer x and the second is a list l. It returns x prepended to l ([x, ...l]).
  • m is the binary function map. Its first argument is a unary integer function f and the second a list of integers l. It returns [f(l[0]), f(l[1]), ..., f(l[-1])].
  • o is the trinary function compose. Its first argument is a unary integer function f and the second a unary integer function g. The third is an integer x. It returns f(g(x)).

Here is what their types might look like in Haskell:

(;) :: Int -> [Int
(:) :: Int -> [Int] -> [Int]
m :: (Int -> Int) -> [Int] -> [Int]
o :: (Int -> Int) -> (Int -> Int) -> Int -> Int

Here is pseudo-pseudo-pseudo-not-even-BNF-anymore:

<int> ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | + <int> <int>
<list> ::= ; <int> | : <int> <list> | m <unary-int-int> <list>
<unary-int-int> ::= o <unary-int-int> <unary-int-int>
<valid-husk-program> ::= <int> | <list>

Questions for Meta:

  • Is this collection of functions okay? Should I add more or replace/remove some?
  • Is this challenge interesting?
  • Is this a dupe?
  • Is the explanation good enough? How can I make it clearer?
  • This currently doesn't have a lot of variety in the currying. Should the functions given to map/compose also be allowed to input/output lists? (and if so, would lists be allowed to be nested?)
  • Can Perl regex do this? I'm making this challenge hoping that it can't.
\$\endgroup\$
2
  • 2
    \$\begingroup\$ You haven't really specified what the output is. The closest is saying the task is to "validate", but what do we actually need to do? \$\endgroup\$
    – pxeger
    Aug 20 '21 at 16:10
  • \$\begingroup\$ are we validating or executing(akin to the gelatin challenge)? \$\endgroup\$
    – Razetime
    Sep 3 '21 at 7:52
3
\$\begingroup\$

Fastest untyped lambda calculus evaluator

Challenge

What it says on the tin. Mainly because googling "fastest untyped lambda calculus" gives almost zero meaningful results.

Each submission is expected to take a lambda term from STDIN and print its normal form to STDOUT. The lambda term is represented using de Bruijn indexes, and we will use prefix notation for this challenge. Since a de Bruijn index may have multiple digits, each token will be separated by a single space. The input will have no surrounding whitespace, but you may output any amount of whitespace before and after the formatted lambda term.

LambdaChar = "\"             // single backslash
DeBruijnIndex = [1-9][0-9]*  // a positive integer
ApplyChar = "@"
Term = DeBruijnIndex | LambdaChar " " Term | ApplyChar " " Term " " Term

For example, \ \ @ 1 @ 2 1 represents lambda x. lambda y. y (x y).

The evaluation semantics to implement is normal order beta-reduction (no eta-reduction).

The test cases will be hand-crafted so that it takes significantly more time to evaluate the expression than to parse the input and format the output. Also, they will involve various kinds of Church- and Scott-encoded terms, so optimizing for any specifically encoded data (hopefully) has less effect than optimizing for general improvement. It is guaranteed that the test cases have a normal form and do not contain free variables.

Good starting points include this PEPM '17 paper and my Haskell implementation which was modified from the paper's algorithm to actually return the normal form. Other notable keywords: graph reduction, supercombinators, G-machine, TIGRE, STG (spineless tagless G-machine). Note that, if your submission has separate compilation and execution phases, both phases count towards the total execution time (which may negatively impact your score).

The submissions will be scored within WSL (Ubuntu 20.04) on my Windows 10 PC, which has Intel Core i7-6700 CPU (3.40GHz) and 8GB of RAM. The score is the sum of the timings measured for all the test cases. Lowest score wins.


Meta

  • Todo: write example and actual test cases.
  • Should I include a description about how the "normal order beta reduction" works for de Bruijn indexes?
\$\endgroup\$
2
  • \$\begingroup\$ are you planning to actually test with >9 levels of lambda nesting? \$\endgroup\$
    – ngn
    May 26 '21 at 2:48
  • \$\begingroup\$ @ngn Depends on what I come up with. \$\endgroup\$
    – Bubbler
    May 26 '21 at 3:04
3
\$\begingroup\$

Volume of a 3d model

In this challenge, you'll take a shape as input, consisting of a number of triangles forming an outer shell. Your task will be to find the volume of the resulting shape.

You can assume the triangles all connect to exactly one other triangle per side, and the surface does not cross over itself. You will not get an input where two separate solids touch only at points or edges.

Test cases and sample implementation coming soon

\$\endgroup\$
7
  • \$\begingroup\$ I like this one. I think that its got some tricky bits to it, like getting the normals for the triangles and ensuring that they are facing the right way. As far as input format goes, an Ascii stl file may be a good option, as it breaks down the meshes into faces and provides the normals as well. \$\endgroup\$
    – JPeroutek
    Oct 15 '21 at 19:36
  • \$\begingroup\$ is the winding of the input going to be consistent or could it be random? also what is the error bound for the output? \$\endgroup\$
    – don bright
    Oct 18 '21 at 3:15
  • \$\begingroup\$ @donbright Random, I'm thinking. For the output, floating point errors are fine, as long as the calculations would theoretically return the correct result. \$\endgroup\$ Oct 18 '21 at 13:27
  • \$\begingroup\$ sounds like a good bit of fun but i kind of predict people will ask for some kind of precise bounding on the error like +/- 1 percent or something. \$\endgroup\$
    – don bright
    Oct 19 '21 at 2:07
  • \$\begingroup\$ @donbright The answer could be off by a thousand percent, if I reimplemented the language with arbitrary precision floats and it worked, I'm fine with it. That's way easier for everyone. Answerers don't need to worry about weird floating point tricks, and I don't need to tell them their answer's invalid :) \$\endgroup\$ Oct 19 '21 at 4:15
  • \$\begingroup\$ i mean the question is how do you know the algorithm works without running it and comparing the result to the known correct value? \$\endgroup\$
    – don bright
    Oct 20 '21 at 2:31
  • \$\begingroup\$ @donbright Probably a mix of trust, and it most likely being close enough to the correct answer that anything other than floating point errors is unlikely \$\endgroup\$ Oct 20 '21 at 2:34
3
\$\begingroup\$

Converting Pinyin to Zhuyin or vice versa

Challenge

Pinyin and Zhuyin are systems that are used to help people pronounce characters in Mandarin Chinese. Write a function/program that converts Pinyin to Zhuyin or vice versa (clarify which one you are doing) according to the tables below. You are not required to deal with tones or incorrect inputs (including edge cases such as ḿ(呣), ǹg(嗯), and ê̄(诶/誒)).

Pinyin to Zhuyin

Pinyin Zhuyin
b
p
m
f
d
t
n (at the beginning)
l
g (at the beginning)
k
h (at the beginning)
j
q
x
zh (except in zhi)
zhi
ch (except in chi)
chi
sh (except in shi)
shi
r (at the beginning)
ri
z (except in zh, zi)
zi
c (except in ch, ci)
ci
s (except in sh, si)
si
a (at the end)
o (except in ao, ou, ong)
e (except in ei, en, eng, er, ie, ue, üe, ye)
e (only in ie, ue, üe, ye)
i (except in ai, ei, ui, iu, iong, yi, zhi, chi, shi, ri, zi, ci, si)
y (except in yong, yi)
yi
u (except in ou, iu, wu, ue and except after j, q, x, y)
w (except in wu)
wu
o (only in ong except in iong, yong)
u (right after j, q, x)
ü
yu
io
yo (only in yong)
ai
ei
i (only in ui)
ao
ou
u (only in iu)
an (except in ang)
ang
en (except in eng)
n (only in in, un except in ing)
eng
ng (only in ing, ong)
er

Zhuyin to Pinyin

Zhuyin Pinyin
b
p
m
f
d
t
n
l
g
k
h
j
q
x
ㄓ (by itself) zhi
ㄓ (not by itself) zh
ㄔ (by itself) chi
ㄔ (not by itself) ch
ㄕ (by itself) shi
ㄕ (not by itself) sh
ㄖ (by itself) ri
ㄖ (not by itself) r
ㄗ (by itself) zi
ㄗ (not by itself) z
ㄘ (by itself) ci
ㄘ (not by itself) c
ㄙ (by itself) si
ㄙ (not by itself) s
a
o
e
e
ㄧ (at the beginning, not by itself, and not before ㄣ, ㄥ) y
ㄧ (after ㄐ, ㄑ, ㄒ) i
ㄧ (by itself or before ㄣ, ㄥ and at the beginning) yi
ㄨ (not at the beginning) u
ㄨ (at the beginning except by itself) w
ㄨ (by itself) wu
ㄨ (before ㄥ and not at the beginning) o
ㄩ (after ㄐ, ㄑ, ㄒ) u
ㄩ (after ㄋ, ㄌ) ü
ㄩ (by itself or before ㄝ, ㄢ, ㄣ and at the beginning) yu
ㄩ (not at the beginning and before ㄥ) io
ㄩ (at the beginning and before ㄥ) yo
ai
ㄟ (not after ㄨ unless ㄨ is at the beginning) ei
ㄟ (after ㄨ unless ㄨ is at the beginning) i
ao
ㄡ (not after ㄧ unless ㄧ is at the beginning) ou
ㄡ (after ㄧ unless ㄧ is at the beginning) u
an
ang
ㄣ (not after ㄧ, ㄨ, ㄩ unless ㄨ is at the beginning) en
ㄣ (after ㄧ, ㄨ, ㄩ unless ㄨ is at the beginning) n
ㄥ (not after ㄧ, ㄨ, ㄩ unless ㄨ is at the beginning) eng
ㄥ (after ㄧ, ㄨ, ㄩ unless ㄨ is at the beginning) ng
er

This is code-golf, so the answer with the least bytes wins.

Test Cases

Pinyin Zhuyin
chuang ㄔㄨㄤ
xue ㄒㄩㄝ
diu ㄉㄧㄡ
juan ㄐㄩㄢ
ri
song ㄙㄨㄥ
ㄌㄩ
qiong ㄑㄩㄥ
zhen ㄓㄣ
huo ㄏㄨㄛ
ying ㄧㄥ

Additional test cases and information

\$\endgroup\$
6
  • \$\begingroup\$ Am I required to support single characters or a word / sentence? Also, there are some edge cases as I know, for example, ḿ(呣), ǹg(嗯), ê̄(诶/誒). Would these be excluded from testcases? May I assume no erhua (儿化/兒化) would be applied? \$\endgroup\$
    – tsh
    Oct 12 '21 at 6:44
  • \$\begingroup\$ There are far more rules than testcases. I would suggest to add more testcases as many rules are not ever touched by any testcases here. \$\endgroup\$
    – tsh
    Oct 12 '21 at 6:54
  • \$\begingroup\$ @tsh Single characters. The edge cases would not be required to check for as inputs. No erhua. I will try to add some more testcases to cover the other rules. \$\endgroup\$
    – Yousername
    Oct 12 '21 at 11:19
  • \$\begingroup\$ Suggest a whole list, it's likely just 300+ possible inputs \$\endgroup\$
    – l4m2
    Oct 12 '21 at 18:13
  • 1
    \$\begingroup\$ The number of rules makes this an intimidating task to write and golf. Consider limited to a simpler subset of rules or situations. \$\endgroup\$
    – xnor
    Oct 13 '21 at 7:12
  • \$\begingroup\$ @xnor It's not actually as many rules as it looks like. A simple regex can be used for most of them. \$\endgroup\$
    – Yousername
    Oct 13 '21 at 21:41
3
\$\begingroup\$

Pythagorean triples given the hypotenuse.

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

Is This Scrabble Board Valid?

\$\endgroup\$
1
15 16
17
18 19
121

You must log in to answer this question.

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