571
\$\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".

\$\endgroup\$
1
  • \$\begingroup\$ What if I posted on the sandbox a long time ago and get no response? \$\endgroup\$
    – None1
    May 15 at 14:05

4688 Answers 4688

1
79 80
81
82 83
157
1
\$\begingroup\$

Count count count..

Posted

\$\endgroup\$
4
  • \$\begingroup\$ what about something like [1,[2,5,10]] \$\endgroup\$ Jan 26, 2022 at 13:56
  • \$\begingroup\$ @thejonymyster count 1 to .. [2,5,10]->8 result is 7, ok I got it.. There's no test cases involving sorted lists, thanks \$\endgroup\$
    – AZTECCO
    Jan 26, 2022 at 13:59
  • 1
    \$\begingroup\$ actually i was being stupid, but im glad you found use in it :D +1 btw \$\endgroup\$ Jan 26, 2022 at 14:08
  • \$\begingroup\$ @thejonymyster glad you raised a doubt here on the sandbox ;) \$\endgroup\$
    – AZTECCO
    Jan 26, 2022 at 14:12
1
\$\begingroup\$

Alphabet Polygon

Intro

Given a number of sides \$a\$ and a side length \$b\$, generate an \$a\$-sided polygon with side length \$b\$. The fill value will be the alphabet going clockwise. If there are not enough letters, wrap around.

Test cases

3 4

     A
    H B
   I   C
  G F E D


4 4

ABCD
L  E
K  F
JIHG
```
\$\endgroup\$
2
  • \$\begingroup\$ This seems like it'd immediately run into problems with, say, a pentagon. But I digress, this is intriguing \$\endgroup\$ Jan 25, 2022 at 14:51
  • 3
    \$\begingroup\$ Good idea, it's just that I'm unsure as to how one might handle a heptagon, or dodecagon, for instance. And do we have to loop back to the beginning of the alphabet once we have exhausted the entirety of the alphabet? For instance, a square with a side length of 10? \$\endgroup\$
    – ophact
    Jan 25, 2022 at 17:55
1
\$\begingroup\$

Shuffle up a list

Given two lists \$A\$ and \$B\$, with no repeats in elements and so that the elements of \$B\$ are identical to the elements of \$A\$ except for the order they are in, we say \$B\$ is an \$n\$-well-shuffled list of \$A\$ (where \$n\$ is a nonnegative integer) if:

  • For any \$(a_1, a_2, \cdots, a_n) \in A^n\$, \$a_1\$'s position in \$A\$ is \$\neq\$ its position in \$B\$, \$a_2\$'s position in \$A\$ is \$\neq\$ its position in \$B\$, ... and \$a_n\$'s position in \$A\$ is \$\neq\$ its position in \$B\$
  • For any \$(a_1, a_2, \cdots, a_n) \in A^n\$, if \$a_i\$ precedes \$a_j\$ for some \$(i, j) \in [1, n]^2\$ in \$A\$, then \$a_i\$ follows \$a_j\$ in \$B\$

Your task is to take two nonnegative integers \$m, n\$ as input and return how-many \$n\$-well-shuffled lists of lists of length \$m\$ there are.

\$\endgroup\$
0
1
\$\begingroup\$

Is this a Hamiltonian cycle?

\$\endgroup\$
1
\$\begingroup\$

Climbing the Bookshelf

Climbing the Bookshelf

\$\endgroup\$
2
  • 1
    \$\begingroup\$ Can we please have the option to output 0-indexed? \$\endgroup\$
    – ophact
    Jan 25, 2022 at 15:48
  • \$\begingroup\$ @ThisFieldIsRequired No, sorry. \$\endgroup\$
    – Ginger
    Jan 25, 2022 at 17:19
1
\$\begingroup\$

Is it an action?


Today, you will solve an abstract algebra challenge.

Consider a set \$G\$, which, to simplify things, is a finite subset of \$\mathbb{Z}\$ containing \$0\$. It has a binary operation \$*\$, which for our example will be \$+\$, but your program should be able to handle any binary operation. If \$G\$ is closed under \$*\$, i.e. \$g * g' \in G \forall g, g' \in G\$, there is associativity with regard to \$*\$, there is a unique element in \$G\$, which we will note as \$1_G\$, such that \$1_G * g = g * 1_G = g \forall g \in G\$, and there exists a unique \$g^{-1} \in G \forall g \in G\$ such that \$ g * g^{-1} = g^{-1} * g = 1_G \$, then \$G\$ is a group.

Consider a set \$X\$, which is also a finite subset of \$\mathbb{Z}\$. Then \$\circ: G \times X \to X\$, where \$G\$ is a group, is an action if:

  • \$1_G \circ x = x \forall x \in X\$, and
  • \$g \circ (g' \circ x) = (g * g') \circ x \forall g, g' \in G, x \in X\$ (associativity).

Challenge

Your task is to write a program or function which takes in the following:

  • \$G\$, a finite subset of \$\mathbb{Z}\$ that includes \$0\$;
  • \$X\$, also a finite subset of \$\mathbb{Z}\$, but not necessarily the same as \$G\$;
  • a binary operation \$*\$ that operates within \$G\$ and that makes \$(G, *)\$ a group, which can be taken in any reasonable manner you would like, such as taking it as a function with two parameters, and
  • an "application" \$\circ\$ from \$G \times X\$ to \$X\$, which can be taken in any reasonable manner you would like.

For the purposes of this challenge, \$1_G\$ is always \$0\$.

This program should then output true if \$\circ\$ is an action and false if not. You may use any two distinct values for true and false.

The shortest code, measured in bytes, wins.

Test cases.

\$G = \{0, 1, 2\}\$

\$X = \{1, 2, 3\}\$

\$*\$ defined by \$g * g' = (g + g') mod 3\$

\$\circ\$ defined by \$g \circ x = g + x\$

Output: false because:

  • \$1_G\$ is 0;
  • then \$1_G \circ x = 0 \circ x = 0 + x = x\$;
  • but \$(1 * 2) \circ 2 = 0 \circ 2 = 2 \neq 1 + (2 + 2) mod 3 = 1 + (2 \circ 2) = 1 \circ (2 \circ 2)\$, thus \$\circ\$ is not associative.

\$G = \{0, 1, 2\}\$

\$X = \{0, 1, 2\}\$

\$*\$ defined by \$g * g' = (g + g') mod 3\$

\$\circ\$ defined by \$g \circ x = (g + x) mod 3\$

Output: true because:

  • \$1_G\$ is 0;
  • then \$1_G \circ x = 0 \circ x = (0 + x) mod 3 = x mod 3 = x\$ (because \$x < 3\$);
  • and \$\circ\$ is associative (proof not provided)
\$\endgroup\$
1
\$\begingroup\$

Quicksand

In this challenge, you take a positive integer as input, which represents the height of a sand pile, located at (0,0) on an infinite square grid. For example, if our input is 123, the sand grid looks initially like this:

\$\begin{matrix} 0 & 0 & 0 \\ 0 &123& 0 \\ 0 & 0 & 0 \end{matrix}\$

Now, piles of sand are unstable, so they topple if their height is 4 or greater. When sand piles topple, they send sand equally in all four directions, but due to the quantum nature of sand, the amount sent is an integer. Or in other words, if there is a pile of height n, it sends sand as follows:

\$\begin{matrix} 0 & \lfloor\frac{n}{4}\rfloor & 0 \\ \lfloor\frac{n}{4}\rfloor & n\mod 4 & \lfloor\frac{n}{4}\rfloor \\ 0 & \lfloor\frac{n}{4}\rfloor & 0 \end{matrix}\$

This means that sandpiles evolve step by step. For example, if we have this initial position, here's how the sandpiles evolve.

\$\begin{matrix} 0 & 0 & 0 & 0 \\ 0 & 0 & 6 & 0 \\ 0 & 2 & 7 & 0 \\ 0 & 0 & 0 & 0 \end{matrix}\$

\$\begin{matrix} 0 & 0 & 1 & 0 \\ 0 & 1 & 3 & 1 \\ 0 & 3 & 4 & 1 \\ 0 & 0 & 1 & 0 \end{matrix}\$

\$\begin{matrix} 0 & 0 & 1 & 0 \\ 0 & 1 & 4 & 1 \\ 0 & 4 & 0 & 2 \\ 0 & 0 & 2 & 0 \end{matrix}\$

\$\begin{matrix} 0 & 0 & 2 & 0 \\ 0 & 3 & 0 & 2 \\ 1 & 0 & 2 & 2 \\ 0 & 1 & 2 & 0 \end{matrix}\$

Now, since all the sandpiles have less than 4 sand, this sand grid is stable.

Rules

Your task is to take an positive integer \$i\$ as input, and output the eventually stable grid that the following initial position evolves to:

Todo add cool fractals

\$\begin{matrix} 0 & 0 & 0 \\ 0 & i & 0 \\ 0 & 0 & 0 \end{matrix}\$

(Note that the grid is still infinitely big)

The output format should be the following: "width;data", where width is an odd number representing the width a square that bounds the eventually stable arrangement (width doesn't have to be the smallest possible). Next is the raw data, which is just the square section of the grid flattened, and the numbers are represented with digits "0123"

\$\endgroup\$
1
  • \$\begingroup\$ by "IO format" do you mean input or output? if its input, i dont understand why youd take the ending width as an input. great pun btw \$\endgroup\$ Feb 3, 2022 at 4:46
1
\$\begingroup\$

Word Guess KOTH

Inspired by Wordle and Evil Wordle.

A King of the Hill game where you must write a bot which acts as both Guesser and Judge of a word guessing game. Each bot will play a match against all the other bots. Each match will consist of 10 rounds alternating between judge and guesser. A bot's score for the match is the number of guesses the opponent made minus the number of guesses it made. Higher is better. Bot with the highest average [or total?] score is KOTH.

The game is as follows:

  1. The Judge and Guesser are both provided with the same dictionary of N letter words.
  2. The Judge selects an answer from the dictionary.
  3. The Guesser makes a guess. The candidate word must be contained in the dictionary.
  4. The Judge is given the guess, and provides a score according to the following rules.
  • The score is a string of N characters from the set ['G','O','B'], corresponding to the guessed letters

    • A 'G' indicates that the guessed letter is correct for that position. Great
    • A 'O' signifies that the guessed letter is in that answer but not that position. Out-of-place.
    • A 'B' indicates that the guessed letter is not in the answer. Bad.
  • If a letter appears in the guess more than once, there will never be more non-'B' results than instances of that letter in the answer.

    • for example if the answer is 'ruler' and the guess is 'belle', the score will be 'BOGBB'.
  1. Steps 2 and 3 continue until the score is all 'G's.
  2. The the number of guesses is added to the Judge's score and subtracted from the Guesser's.
  • Note that the judge is free to modify the answer after each guess, as long as the new answer is consistent with all the previous guesses.

An example scoring function in Python is:

def count_score(truth, trial):
    score = [None]*len(truth)
    allow = truth
    for index,value in enumerate(trial):
        if truth[index]==value:
            score[index]='G'
            allow=allow.replace(value,'',1)
        for index,value in enumerate(trial):
        if not score[index]:
            if value in allow:
                score[index]='O'
                allow=allow.replace(value,'',1)
            else:
                score[index]='B'
    return ''.join(score)

Entries must provide a bot command that can be called from the command line and prints the required outputs to stdout, separated by newlines.

For all the use cases below, codex is a filepath to a dictionary of legal words, and token is a string used by a bot to maintain state. It must not be empty. The token generated in any round is passed back to the same bot in the following round. The opponent bot will never see your token. Tokens are not retained from one round to the next.

arguments --> results

codex "judge" --> token Judge initialization. Returns a token.

codex "judge" token trial --> token score Judge will score the trial word. score is constructed according to the rules above.

codex "guess" --> token trial Guesser makes initial trial guess.

codex "guess" token score - token trial Guesser gets score from previous guess. Returns new trial guess.

Example Bot:

import random,sys,re

def begin_offer(codex):
    words = [l.strip() for l in open(codex)]
    return [random.choice(words)]

def score_trial(token, trial):
    return token, count_score(token,trial)

def first_guess(codex):
    words = sorted([l.strip() for l in open(codex)])
    guess = words[0]
    return (guess, guess)

def later_guess(codex, prior, score):
    words = sorted([l.strip() for l in open(codex)])
    index = words.index(prior)
                  
    for place,value in enumerate(score):
        if value != 'G':
            while words[index][place]==prior[place]:
                index+=1
            break
    guess = words[index]
    return guess,guess


if __name__ == "__main__":
    codex,style,*extra = sys.argv[1:]
    if style == 'judge':
        if not extra:
            result = begin_offer(codex)
        else:
            result = score_trial(*extra)
    elif style == 'guess':
        if not extra:
            result = first_guess(codex)
        else:
            result = later_guess(codex,*extra)

    print("\n".join(result))

Match Runner (in progress)

import sys,subprocess
def reply_split(reply):
    return [bites.decode('ascii').strip() for bites in reply.split()]

if __name__ == "__main__":
    judge,guess = sys.argv[1:]

    reply = subprocess.check_output([judge, "words.txt", "judge"])
    judge_token,*trash = reply_split(reply)

    reply = subprocess.check_output([guess, "words.txt", "guess"])
    guess_token,trial = reply_split(reply)

    for round in range(10):

        print(trial)
    
        reply = subprocess.check_output([judge, "words.txt", "judge", judge_token, trial])
        judge_token,score,*trash = reply_split(reply)

        print(score, "\n")
        if score == 'GGGGG':
            print("{} guessed {}'s word in {} rounds".format(guess, judge, round+1))
            break
        
        reply = subprocess.check_output([guess, "words.txt", "guess", guess_token, score])
        guess_token,trial,*trash = reply_split(reply)

    print(round+1)
\$\endgroup\$
5
  • \$\begingroup\$ I wrote up all the sample code for this before I found this related post where the comments suggest a similar KOTH \$\endgroup\$
    – AShelly
    Feb 4, 2022 at 8:00
  • \$\begingroup\$ Question: Is EVERY string of N characters allowed to be returned by your function? \$\endgroup\$ Feb 4, 2022 at 10:10
  • \$\begingroup\$ @StackMeterPlus no, see steps 1-3 \$\endgroup\$ Feb 4, 2022 at 14:23
  • \$\begingroup\$ Although it's not an exact dupe, this feels quite similar to some other KotHs that are based around guessing numbers or playing games like hangman. \$\endgroup\$ Feb 4, 2022 at 19:56
  • \$\begingroup\$ Step 2 may be misleading and suggest that there is a slight chance of guessing the word in the first guess. In the adversarial Wordle I know (by qntm) the underlying word is chosen only after the guess, along with returned score (so that they are consistent). This way there is no way to guess a word in the first try (for a reasonable Judge). Or maybe current formulation is intentional? \$\endgroup\$
    – pajonk
    Feb 5, 2022 at 19:45
1
\$\begingroup\$

Bracket Depth List

\$\endgroup\$
2
  • \$\begingroup\$ (Because I suspect a lot of people are going to use regex) can we take other bracket pairs and what formats are acceptable for string output? \$\endgroup\$
    – emanresu A
    Feb 5, 2022 at 4:25
  • \$\begingroup\$ wdym by other bracket pairs? \$\endgroup\$
    – DialFrost
    Feb 5, 2022 at 4:28
1
\$\begingroup\$

Decompress a ragged list

\$\endgroup\$
1
\$\begingroup\$

Very simple auto battler

There are two players. Each player has a team of between 0 and 5 members. Each member has two relevant statistics: an attack score and a health score. These range from 1 to 50.

Until at least one team runs out of members, you need to battle the lead member of each team against each other. (You can decide whether this is the first or last member of the team.) The two attacks are simultaneous, so it's possible that both members can defeat each other. Each attack reduces the foe's health by the user's attack. Once a team member's health is reduced to zero (or less) then it faints and takes no part in the rest of the battle.

If both teams simultaneously run out of unfainted members then the result is a draw otherwise the team that still has unfainted members wins.

Your task, given two teams in a reasonable format, e.g. list of tuples of (health, attack), is to write a program or function that outputs which (if any) team will win, using one of three specific values of your choice, e.g. -1, 0 and 1, or A, B and D. (Please describe the mapping of values in your answer.)

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

Sample team generator and battler

\$\endgroup\$
1
\$\begingroup\$

Triangle Tripler

\$\endgroup\$
1
\$\begingroup\$

Interpret Subleq code

Background

Subleq is a language that has only one 3 argument instruction. The instruction has three operands A B C. When executed it subtracts the contents in address A from address B; stores the result in address B; if the result is less than or equal to 0 it goes to address C. -1 in a position has special meaning. -1 in A will read the ASCII value of then next character of input into B; if no more input then goto 'C'. -1 in B will send the ASCII character in A to output. -1 in C will exit the program instead of going to an address.

Task

Given input and Subleq code, output the results from running the Subleq code.

An interpreter built in Excel is here.

Rules

Test Cases

For the test cases below, any input to the Subleq is before the '/', code is after. Code is represented by decimal numbers.

Hello, World!

Input=>
/
12 -1 13
1 0 6
3 2 -1
4 4 0
72 101 108 108 111 42 32 87 111 114 108 100 33
Output
Hello, World!

!I!n!s!e!r!t! !i!n!b!e!t!w!e!e!n!

Input->
1 2 3 4 5 6/
2 -1 33
-1 8 -1
8 -1 0
8 8 
Output
!1! !2! !3! !4! !5! !6!

Meta

  • What am I leaving out?
  • Is there a better way of handling the input to the Subleq code?
  • Does it need more/better examples?
\$\endgroup\$
1
\$\begingroup\$

Generate all groupings

\$\endgroup\$
2
  • 1
    \$\begingroup\$ Related \$\endgroup\$
    – emanresu A
    Feb 8, 2022 at 19:20
  • \$\begingroup\$ Can we output in reverse order? This order feels a bit unnatural \$\endgroup\$
    – AnttiP
    Feb 9, 2022 at 9:31
1
\$\begingroup\$

Bigger regex?

\$\endgroup\$
1
  • \$\begingroup\$ anttiP you can clear this post now buddy \$\endgroup\$
    – DialFrost
    Feb 13, 2022 at 23:42
1
\$\begingroup\$

Knights Jam | Chess

\$\endgroup\$
1
\$\begingroup\$

Factorials of primes decomposition

\$\endgroup\$
4
  • \$\begingroup\$ Are duplicate prime numbers allowed? (is 36 = 3#3 3#-1 or 36 = 3#1 3#1 valid?) \$\endgroup\$
    – AnttiP
    Feb 18, 2022 at 11:07
  • \$\begingroup\$ i guess i could allow duplicate prime no.'s. Which do you think benefits the challenge more @AnttiP? \$\endgroup\$
    – DialFrost
    Feb 18, 2022 at 11:09
  • \$\begingroup\$ Allowing duplicates makes the challenge a bit easier, since you don't have to simplify the exponents. Basically without duplicates there are two parts to the program, one is the recursion part (factor to primes and recurse) and the other one is the simplification. If duplicates are allowed, then simplification is not necessary so the answers will be shorter. Personally I slightly prefer allowing duplicates, since the answers would be a bit more "focused". But I think if you allow duplicates then you should also allow a 0 exponent. \$\endgroup\$
    – AnttiP
    Feb 18, 2022 at 11:30
  • 1
    \$\begingroup\$ I think the challenge should be ready to be posted. \$\endgroup\$
    – ophact
    Feb 18, 2022 at 11:49
1
\$\begingroup\$

Play 1D minesweeper

\$\endgroup\$
1
  • \$\begingroup\$ What should I output? \$\endgroup\$
    – tsh
    Feb 18, 2022 at 4:00
1
\$\begingroup\$

Page Selector

\$\endgroup\$
8
  • \$\begingroup\$ Personally, I think that the last two examples (from a UI standpoint) should be < 1 2 3 [4] 5 ... 11 > and < 1 ... 6 [7] 8 ... 11 >. Regardless, you should clarify if there is some priority for how numbers should be distributed (e.g. should the center have more numbers?) \$\endgroup\$
    – AnttiP
    Feb 22, 2022 at 19:11
  • \$\begingroup\$ Slightly related codegolf.stackexchange.com/questions/147318/goto-the-nth-page \$\endgroup\$
    – tsh
    Feb 23, 2022 at 2:39
  • \$\begingroup\$ Adding to AnttiP's comment, a worked out example or examples would be nice. \$\endgroup\$
    – pajonk
    Feb 23, 2022 at 6:39
  • \$\begingroup\$ @AnttiP Good point, clarified slightly. \$\endgroup\$
    – Ginger
    Feb 23, 2022 at 15:06
  • 1
    \$\begingroup\$ What should be the output for 11 6 7? < 1 ... 6 [7] ... 11 > or < 1 ... [7] 8 ... 11 > or something else? (this should be clarified in the specs) \$\endgroup\$
    – pajonk
    Feb 23, 2022 at 19:43
  • \$\begingroup\$ @pajonk Clarified. \$\endgroup\$
    – Ginger
    Feb 28, 2022 at 13:48
  • \$\begingroup\$ Ok, what about 11 6 6? (That problem with specs was intended in my previous comment) \$\endgroup\$
    – pajonk
    Feb 28, 2022 at 19:32
  • \$\begingroup\$ @pajonk Added (and updated specs) \$\endgroup\$
    – Ginger
    Mar 3, 2022 at 1:31
1
\$\begingroup\$

Can the Tune be Played?

I changed the question slightly from when it was posted on the Sandbox.

\$\endgroup\$
2
  • \$\begingroup\$ I don't get it. Could you explain in detail eg. the [1, 3, 2] is valid - the notes would be played in the order [3, 1, 2] statement? \$\endgroup\$
    – pajonk
    Feb 27, 2022 at 16:35
  • \$\begingroup\$ I might change the wording because I think I have explained it in a confusing way. A more mathematical explanation is: if you shift back each number n in a list by n spaces, do any of the numbers end up in the same space? If so, the list is invalid. So: shifting 1 back by 1 space, it ends up at position -1; shifting 3 back by 3 spaces, it ends up at position -2, and shifting 2 back by 2 spaces, it ends up at position 0. Since none of these are the same position, the list [1, 3, 2] is valid. \$\endgroup\$
    – Lecdi
    Feb 27, 2022 at 16:46
1
\$\begingroup\$

The Nineteenth Bakery

\$\endgroup\$
1
\$\begingroup\$

Reveal all clues of Black Box

Black Box is a board game, Your task is to reveal all clues.

What is black box

Black box is a board game with hidden atoms, Your task is given input, All atoms, reveal all clues.

I/O

Input

The atoms can be any 1-char that is not newline (Used for separator) Like this.

O....
...O.
..O..
.....
....O

Output

When the code reveals all clues (See Below) the output of The given input above can be:

 HRHH1
H     1
R     H
H     H
2     R
H     H
 H2HRH

or

[["H", "R", "H", "H", "1"], ["1", "H", "H", "R", "H"], ["H", "R", "H", "2", "H"], ["H", "2", "H", "R", "H"]]

Ignore the number, This doesn't mean anything, the number can be non-unique

Task

Hit

Atoms interact with rays in three ways. A direct impact on an atom by a ray is a "hit".

.........
.........
.O.....O.
.........
.........
...O.....H 1
.........
.......O.

Thus, ray 1 fired into the box configuration at left strikes an atom directly, generating a "hit", designated by an "H". A ray which hits an atom does not emerge from the box.

Deflection

The interaction resulting from a ray which does not actually hit an atom, but which passes directly to one side of the ball is called a "deflection". The angle of deflection for this ray/atom interaction is 90 degrees. Ray 2 is deflected by the atom at left, exiting the box as shown.

    2
.........
.........
.O.....O.
.........
.........2
...O.....
.........
.......O.

Reflection

The final type of interaction of a ray with an atom is a "reflection", designated by an "R". This occurs in two circumstances. If an atom is at the edge of the grid, any ray which is aimed into the grid directly beside it causes a reflection.

.........
.........
.O.....O.
.........
.........
...O.....
.........
.......O.
      RHR
      354

Rays 3 and 4 at left would each generate a reflection, due to the atom at the edge. Ray 5 would be a hit on the atom.

Double deflection

The other circumstance leading to a reflection is when two deflections cancel out. In the grid at left, ray 6 results in a reflection due to its interaction with the atoms in the grid.

   6

   R
.....
..O.O
.....
.....
.....

Detour

Rays that don't result in hits or reflections are called "detours". These may be single or multiple deflections, or misses. A detour has an entry and an exit location, while hits and reflections only have an entry location for a hit, and a single entry/exit location for a reflection.

  8   8  
.........
.........
.O.....O.
.........9
.........
...O.....
.........9
.......O.

Of course, more complex situations result when these behaviors interact. Ray 8 results in two deflections, as does ray 9.

Some rays travel a twisted course, like ray 1 at left.

 .........
 .........
 .O.....O.
 .........
1.........
 ...O.....
 .........
 .......O.
     1

Notice that this complex set of five deflections above looks exactly like a single deflection, as shown by ray 2 at left. Things are not always as simple as they seem within a black box.

 .........
 .........
 .........
 .....O...
1.........
 .........
 .........
 .........
     1

Reflections and hits can be more complex, too. Ray 2 gets deflected by the first atom, reflected by the next two atoms and again deflected by the original atom, yielding a reflection.

.O...
.....R 2
.....
.O.O.
.....

Ray 3 below gets deflected by the first atom, then by the second atom, and then hits the third atom, yielding a hit.

   ...O.
   O....
   .....
3 H.....
   ...O.

Test cases

O....
...O.
..O..
.....
....O
->
 HRHH1
H     1
R     H
H     H
2     R
H     H
 H2HRH

O
->
 H
H H
 H

OOO
O O
OOO
->
 HHH
H   H
H   H
H   H
 HHH

..O..
O...O
..O..
->
 HRHRH
R     R
H     H
R     R
 HRHRH

...
...
...
->
 123
4   4
5   5
6   6
 123

....
O...
...O
....
->
 H1HH
R    1
H    R
R    H
2    R
 HH2H

Meta:

  • Any feedback?
\$\endgroup\$
4
  • \$\begingroup\$ I think I would first explain what Black Box is and then specify the task and I/O. Right now the Input and Output sections are hard to grasp without context and one needs to go back to those sections after reading specs. \$\endgroup\$
    – pajonk
    Feb 25, 2022 at 19:29
  • 1
    \$\begingroup\$ I'd use a capital O in your demos, rather than a #. It makes it visually clearer, imo. \$\endgroup\$
    – wizzwizz4
    Feb 26, 2022 at 1:29
  • \$\begingroup\$ @wizzwizz4 Ok, I will do later \$\endgroup\$
    – Fmbalbuena
    Mar 9, 2022 at 21:01
  • \$\begingroup\$ @wizzwizz4 It's a bit ugly because the clues are letters, I will rollback if someone doesn't like this. \$\endgroup\$
    – Fmbalbuena
    Mar 9, 2022 at 21:09
1
\$\begingroup\$

Negative of an ASCII photo

\$\endgroup\$
3
  • \$\begingroup\$ interesting challenge although this might be a dupe im not sure \$\endgroup\$
    – DialFrost
    Mar 14, 2022 at 2:38
  • \$\begingroup\$ @DialFrost I had a browse and couldn't find one, but obviously if it is I won't post \$\endgroup\$
    – jezza_99
    Mar 14, 2022 at 2:45
  • 2
    \$\begingroup\$ ah ic although u might wanna state that the negative photo has to be of same "size" as the original one as suggested by ur ["#",""] and ["","#"] but i dont know if it rly matters \$\endgroup\$
    – DialFrost
    Mar 14, 2022 at 2:47
1
\$\begingroup\$

Overlay the Ukrainian Flag

A pseudo-sequel to this challenge.

The Challenge

As of the posting of this challenge, my PFP has a blue-and-yellow overlay in support of Ukraine. Your task is to, given the path to an input image, overlay a similar image on top.

Here is the flag: Ukrainian Flag

  • The flag is divided horizontally across the middle into two equally sized stripes.
  • Stripe colors: (0, 87, 183) or #0057B7 (blue, top) and (255, 215, 0) or #FFD700 (yellow, bottom).
  • You must, given the path to an image as input, overlay two semi-transparent rectangles of those colors onto it. The rectangles must each take up half the vertical area of the image, and be as wide as the image.
  • The rectangles must have 70% opacity.
  • Colors must be exact if possible, otherwise use the closest available blue and yellow.
  • The image can be saved to a file or piped raw to STDOUT in any common image file format, or it can be displayed in a window.
  • If you're saving to a file, you may either overwrite the old image or create a new one.
  • Built-in flag images, flag-drawing libraries, or horrendously upscaling the Ukrainian flag emoji are prohibited.
\$\endgroup\$
1
  • 2
    \$\begingroup\$ Can we choose the input file format or you have some restrictions on that? Do we have to input via a path to file or other means of inputting graphics is fine (raw bytes, 3D array of RGB values etc.)? May we assume the image has even height (in pixels or in some convenient unit)? \$\endgroup\$
    – pajonk
    Mar 22, 2022 at 11:41
1
\$\begingroup\$

Overlay Two Images

This challenge is as simple as it gets: Just take two images as input (in any reasonable format) and overlay the first atop the second.

  • The overlay must have 70% opacity (if possible, if not use the closest available analog), or in other words, multiply the overlay's pixel values by 0.3 and the base by 0.7.
  • The overlay must be centered over the base image.
  • If the overlay is bigger, it must be cropped to fit within the base.
  • If the base image is bigger, the overlay does not need to be enlarged.
\$\endgroup\$
3
  • \$\begingroup\$ Maybe you could explain wat 70% opacity actually means. \$\endgroup\$
    – math scat
    Mar 28, 2022 at 5:52
  • 1
    \$\begingroup\$ @mathcat 70% of the pixels are transparent or have an alpha value of 70? Then I guess if you take a sample on the final image the colour should be top_red*0.3+bottom_red*0.7, top_blue*0.3+bottom_blue*0.7,top_green*0.3+bottom_green*0.7... or however colours work \$\endgroup\$ Mar 28, 2022 at 12:13
  • \$\begingroup\$ I think adding this would be important \$\endgroup\$
    – math scat
    Mar 28, 2022 at 18:42
1
\$\begingroup\$

Optimally break a string into substrings

\$\endgroup\$
5
  • \$\begingroup\$ What do we need to optimize? if it's "smallest number of pieces", then [potato][c][a][r][rot] also scores 5. \$\endgroup\$
    – Nitrodon
    Apr 1, 2022 at 17:45
  • \$\begingroup\$ @Nitrodon Yeah it's smallest number of pieces, forgot to add that. \$\endgroup\$ Apr 1, 2022 at 18:19
  • \$\begingroup\$ Could we please have a few more testcases? \$\endgroup\$
    – ophact
    Apr 2, 2022 at 6:26
  • \$\begingroup\$ @ophact Sure, I'll add some \$\endgroup\$ Apr 2, 2022 at 22:54
  • 2
    \$\begingroup\$ Title suggestion: "substrings" -> "words" (as the substrings in question, other than single characters, have to come from a dictionary of sorts) \$\endgroup\$ Apr 8, 2022 at 1:34
1
\$\begingroup\$

Simplified Piet Interpreter

\$\endgroup\$
6
  • \$\begingroup\$ 1) Long challenges are fine, especially when the challenge is complex like this. Complete specification is much more important. 5) From quick skimming, the example looks mostly correct to me, except: at the pointer instruction near the start, right + clockwise 9 times is down, not up. An easy fix is to change the initial number to, say, 7. 6) My choice would be to add something like "Reference: official Piet specification (link)" at the bottom. \$\endgroup\$
    – Bubbler
    Apr 7, 2022 at 6:21
  • \$\begingroup\$ @Bubbler Thanks for the feedback! For the example, I think I just mixed up clockwise and counterclockwise lol. \$\endgroup\$
    – Aiden Chow
    Apr 7, 2022 at 7:00
  • \$\begingroup\$ Seems interesting!! I'd say my one complaint is that this does miss the other big feature of Piet, which is that instructions are defined by the difference between the blocks you're travelling between, not the specific value of either of them, although that is probably acceptable for simplicity reasons. Also should provide some specifics on how the final output is to be formatted. \$\endgroup\$
    – des54321
    Apr 7, 2022 at 17:41
  • \$\begingroup\$ @des54321 Yeah, I decided to remove the hue and lightness aspect of Piet because I thought that it would add unnecessary complexity to the challenge, though if you think that it would make the challenge more interesting, I could add that aspect to the challenge as well. \$\endgroup\$
    – Aiden Chow
    Apr 7, 2022 at 18:24
  • \$\begingroup\$ @AidenChow the hue/lightness feature would definitely make an interesting (if possibly harder) challenge, and the instruction set you have now would fit nicely in a 3 hue 3 lightness cycle, but its certainly ultimately your decision whether to include it \$\endgroup\$
    – des54321
    Apr 7, 2022 at 18:26
  • \$\begingroup\$ @des54321 I will think about it. The problem is that if I were to change the specs now, I would have to completely rewrite my worked example. \$\endgroup\$
    – Aiden Chow
    Apr 7, 2022 at 18:37
1
\$\begingroup\$

Draw the Norwegian flag

\$\endgroup\$
4
  • \$\begingroup\$ link is wrong. correct link \$\endgroup\$
    – naffetS
    Apr 8, 2022 at 21:04
  • \$\begingroup\$ @Steffan oh wow, never knew stack exchange was that stubborn \$\endgroup\$ Apr 8, 2022 at 21:15
  • \$\begingroup\$ I don't think it would be considered a duplicate as there are already tons of flag challenges \$\endgroup\$
    – naffetS
    Apr 11, 2022 at 0:03
  • \$\begingroup\$ Perhaps it's not considered a duplicate, but I'd hold the opinion that printing the Norwegian flag isn't particularly interesting, only because many flag challenges already do exist (or maybe this is the unpopular opinion and many people enjoy having these flag challenges). \$\endgroup\$ Apr 15, 2022 at 3:48
1
\$\begingroup\$

Draw New Posts' Profile!

\$\endgroup\$
6
  • \$\begingroup\$ @DLosc Whoops, fixed. \$\endgroup\$
    – Ginger
    Apr 19, 2022 at 21:20
  • 1
    \$\begingroup\$ Also possibly loosen the input from boolean to any two distinct values? Although that might make it too easy if someone specifies the inputs to be their lang's color values for blue/black \$\endgroup\$
    – des54321
    Apr 19, 2022 at 21:24
  • \$\begingroup\$ Also presumably this is code-golf \$\endgroup\$
    – des54321
    Apr 19, 2022 at 21:26
  • \$\begingroup\$ @des54321 of course \$\endgroup\$
    – Ginger
    Apr 19, 2022 at 21:27
  • 1
    \$\begingroup\$ As this image is 48x48 and binary in nature, I suggest embedding in the post a binary matrix reflecting on/off pixels of the picture. \$\endgroup\$
    – pajonk
    Apr 20, 2022 at 9:31
  • 1
    \$\begingroup\$ Note that NP and SP's profile pictures are slightly "blurred", they are not perfect 48×48 pixel images. So you might want to clarify any non-white pixels are the same blue/black. \$\endgroup\$ Apr 27, 2022 at 1:25
1
\$\begingroup\$

Create a program that may or may not determine if a list is in this sequence

Your task is to write a program which returns another program which has a nonzero chance of correctly determining if an inputted list is in a sequence described below. This can either be done through randomly generating a program, which will occasionally do the correct task, or through hardcoding a program that always works and returning that.

The sequence

The sequence you'll need to identify starts with the following items:

well the sequence I was gonna use turns out to have a closed form formula so frick

\$\endgroup\$
2
  • \$\begingroup\$ What was the idea here? Was it going to be something uncomputable? Could this still be salvaged with a new sequence? Also, what stops you from submitting like print(random(0,1)) or whatever \$\endgroup\$ May 16, 2022 at 20:06
  • 1
    \$\begingroup\$ @thejonymyster Basically, you try to write a program that will randomly generate (sometimes) executable code. So there's a very small chance you'll get something which actually does solve the problem (checking if something's in a sequence, in this case), which is longer than the program which randomly generated it. \$\endgroup\$ May 16, 2022 at 20:18
1
79 80
81
82 83
157

You must log in to answer this question.

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