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\$
2
  • \$\begingroup\$ What if I posted on the sandbox a long time ago and get no response? \$\endgroup\$
    – None1
    Commented May 15 at 14:05
  • \$\begingroup\$ @None1 If you don't get feedback for a while you can ask in the nineteenth byte \$\endgroup\$
    – mousetail
    Commented May 29 at 13:27

4722 Answers 4722

1
135 136
137
138 139
158
0
\$\begingroup\$

Infinite Candle Sequence

\$\endgroup\$
6
  • \$\begingroup\$ I'm not sure if this is really two challenges (generate sequence, draw colours). Please let me know! \$\endgroup\$ Commented Apr 28, 2022 at 3:52
  • \$\begingroup\$ This really does seem like two challenges. I recommend just requiring answers to output the number sequence, as it does make the challenge more accessible to languages that do not have any form of graphical output. That being said, if it is going to be a purely sequence challenge: Is floating point precision error allowed? Or does the whole decimal number have to be outputted? Or are we outputting as a list of pairs (numerator, denominator)? I also recommend including the first 100 terms or so of this sequence in the challenge body somewhere, as to remove any ambiguity. \$\endgroup\$
    – Aiden Chow
    Commented Apr 28, 2022 at 3:59
  • \$\begingroup\$ If it's going to be graphical output: How should the colors be displayed (square, circle, any shape that you choose, etc.)? \$\endgroup\$
    – Aiden Chow
    Commented Apr 28, 2022 at 4:02
  • \$\begingroup\$ If it's graphical output, you should provide hex codes or screenshots of the first few colors in the sequence. \$\endgroup\$
    – Aiden Chow
    Commented Apr 28, 2022 at 8:22
  • \$\begingroup\$ Thanks for the feedback. I think I'll reduce this to just outputting the sequence. I'll add more info as well. \$\endgroup\$ Commented Apr 28, 2022 at 22:06
  • 2
    \$\begingroup\$ I've edited this down to a stub now that it's been posted to save space \$\endgroup\$ Commented May 4, 2022 at 23:12
0
\$\begingroup\$

Draw the Location's Flag

Take as input the latitude-longitude coordinates of a location on Earth, and return a flag that corresponds to that location. You may return any official flag that is at the level of a country or smaller. For example, if the location was 40.712775, -74.005973, you may return the flag of the USA, the New York state flag, or the flag of New York City, but you can't return the UN flag.

Rules

The outputted flag must be at least 50 pixels in its shortest direction (or be vector graphics/some other scalable image).

Internet data IS allowed in this challenge.

Areas not officially controlled by any country are undefined behavior. This includes Antarctica, Bir Tawil, and international waters.

Any flag returned must be an official flag that currently corresponds to that location. For example, you cannot return the flag of the British Empire for countries that used to be its territories.

In cases where control is disputed (including South Sudan, eastern Ukraine...) you may output any country that has a claim.

This is a code golf challenge, so shortest code wins.

Standard I/O rules apply. Examples would include a list/tuple of two numbers, a Location class, a vector, or Mathematica's GeoPosition.

All flags must be recognizable as the flag they are.

For flags with differing sides (like Paraguay), you may return only one face.

For non-rectangular flags, you may pad the other area with any color distinct from the primary color of the flag.

\$\endgroup\$
8
  • \$\begingroup\$ This is a bit hard tho... \$\endgroup\$ Commented May 10, 2022 at 6:24
  • \$\begingroup\$ It's supposed to be quite difficult. I imagine some programming languages have builtins to fetch the flags of a country (mathematica in particular), which would make things easier, but other languages will still struggle. I have considered changing it to be a code challenge where your score is increased (a bad thing here) if you miss some, but you don't have to get every country right. \$\endgroup\$
    – Romanp
    Commented May 10, 2022 at 13:22
  • \$\begingroup\$ I mean, it would be sort of unfair, right? To non-mathematica languages? \$\endgroup\$ Commented May 10, 2022 at 13:25
  • \$\begingroup\$ Yes and no. It would likely have a far shorter solution (but some other languages might also have these builtins, so they might be shorter), but its solution isn't going to be short either. There isn't a quick way I know of to check if a point is in a country, it will just help with drawing the flags. \$\endgroup\$
    – Romanp
    Commented May 10, 2022 at 13:31
  • \$\begingroup\$ I think I can do it in 37 bytes in Mathematica, but I'm not 100% sure it works all the time and it could potentially be shorter. My guess is other languages will need quite a bit more, but it still feels doable. \$\endgroup\$
    – Romanp
    Commented May 10, 2022 at 13:54
  • \$\begingroup\$ Yeah, but I think Mathematica has way too big an advantage at that. \$\endgroup\$ Commented May 10, 2022 at 13:55
  • \$\begingroup\$ It has a very large advantage for sure, but it's mostly a language-by-language competition. I've been wondering about methods to make it a little closer, but the goal isn't for Mathematica to compete against everything else, just like the goal isn't for Vyxal to compete against Python. I feel like on most challenges, if they are simple, a golflang wins, and if they are complicated, some Mathematica-esque language with a lot of builtins wins. This question is just more towards the complicated side compared to most code golf problems. \$\endgroup\$
    – Romanp
    Commented May 10, 2022 at 14:03
  • \$\begingroup\$ this does actually seem to me to be a somewhat interesting challenge, although I do feel that it is kinda two challenges in one: 1) given an arbitrary latitude/longitude coordinate, find some governmental entity that claims control of that location and 2) given that governmental entity, output its flag. it might be better breaking this into two, or selecting only one of them \$\endgroup\$
    – des54321
    Commented Jun 5, 2022 at 1:41
0
\$\begingroup\$

Alternating sums of multidimensional arrays

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

Irradiated Polyglots

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

Quickly approximate the square root of a float


As in like, constant-time and almost instant, but off by a lot. No time for looping here. This is going to take a lot of work, since I'm going to make an emulated CPU which will allow more precise timing.

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

Desmosian Music

Create a script that takes in notes as numbers and note lengths as decimals.

You do not have to accept rest notes.

For instance, when given [[1,1],[2,2],[3,0.5]] you should return a desmos code that plots:

      -  <== 3
  ----   <== 2
--       <== 1

In this case it can be:

\left\{x>0:\left\{x<2:1,\left\{x<6:2,\left\{x<7:3\right\}\right\}\right\}\right\}

Scale the note lengths to fit entirely inside the graph.

This is and I appreciate desmos answers.

\$\endgroup\$
2
  • \$\begingroup\$ What’s the winning criteria? code-golf? Metagolf? \$\endgroup\$
    – ATaco
    Commented May 30, 2022 at 0:56
  • \$\begingroup\$ Probably best to explain the output. Does it need to be ascii art? A drawn graph? Desmos code? Could you provide an example of passing code? \$\endgroup\$
    – ATaco
    Commented May 30, 2022 at 1:14
0
\$\begingroup\$

Can we do it with an 89?

This was originally meant to be a Puzzling Challenge:

Can we do it with an 89?

89 is my favorite number. Your task is to make 1~100 using only one 89. Operations allowed are:

  • Factorial (3! = 6)

  • Parenthesis ((3!)! = 6! = 720)

  • Double Factorial (4!! = 4*2 = 8)

  • Square Root (sqrt(9) = 3)

  • Floor and Ceiling (floor(3.5) = 3 and ceil(3.5)=4)

  • Negation (-3 = well, -3, duh)

Note that 4!! = 4*2 and not (4!)!

Your task is to output the equation given a number greater than 1 (no longer restricted to be less than 100), inclusive.

Meta:

  • Should this be ?

  • Or should we aim to end with the shortest equation?

  • Or should we aim for a shorter run time?

  • Could this be 3 challenges?

  • Or should I ask for code that outputs the shortest equation?

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

Good Rectangles and Evil Numbers

This is meant to be a Puzzling Challenge:

Good Rectangles and Evil Numbers - Integrated

Original: https://puzzling.stackexchange.com/questions/116168/good-rectangles-and-evil-numbers

Good Rectangle

We define a good rectangle with base \$ x \$ as a rectangle in which \$ rac lw = x \$ where \$ l \$ is the length of the rectangle and \$ w \$ is the width of the rectangle.

Tiling

This is simply to clarify. There should be no problem if you ignore this section, but I would like the question to be robust.

We define a tiling of a group of shapes onto another shape as a way to place the group of shapes such that:

  • The shapes do not overlap

  • The group of shapes covers the entire target shape

  • The target shape covers the entire group of shape

(The latter two combined is equivalent such that the union of all shapes in the group is congruent to the target shape)

Good Numbers

We define a positive integer as a good number in base \$ x \$ if it is possible to tile that many good rectangles of base \$ x \$ (not necessarily of the same size) onto a square of any side length.

Evil Numbers

We define an evil number as a positive integer that is not a good number in that base.

...

Your Task: Given a number as the base \$ x \$ and a number as the number of rectangles \$ n \$, assuming that \$ n \$ is not an evil number in base \$ x \$, graphically output a tiling with \$ n \$ good rectangles in base \$ x \$.

This is .

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

Tapes, Pointers, And sub-tapes: BrainFuck+


In this challenge we make an interpreter for a subset of BrainFuck+.

As with BrainFuck we start with the tape [0] and pointer at index 0.


BrainFuck+ Simplified: Commands


+ and -


Update the current cell, as in BrainFuck.


++

=>

[2]
 ^

--+--++

=>

[-1]
  ^

(There exists no wrap around)


< and >


Update the pointer, as in BrainFuck.


>

=>

[0,0]
   ^

An attempt to go right at the rightmost point of a tape creates a cell with value 0 at the right.


++>+>++>-

=>

[2,1,2,-1]
        ^

++<+

=>

[1,2]
 ^

An attempt to go left at the leftmost point of a tape creates a cell with value 0 at the left.


v and ^


v

=>

[[0]]
  ^

An attempt to go down a numerical value overrides the cell with the empty subtape [0].


>+<v+>-^>

=>

[[1,-1],1]
        ^

^ exits the subtape.


v>^v

=>

[[0,0]]
  ^

An attempt to go down a subtape will enter the subtape at index 0.


^

=>

Program Termination

An attempt to exit the main tape terminates the program. Otherwise the program must run completely.


Revisiting + and -


v^+

=>

Program Termination

An attempt to increment or decrement a list will fail and terminate the program. However no error will be raised.


Other characters...


...will not appear.


Your Task:


Make a Simplified BrainFuck+ Interpreter. This is .


Test Cases


See above.


\$\endgroup\$
3
  • \$\begingroup\$ I like this concept a lot, but it could stand to be reorganized a bit for ease of reading, but thats' just my opinion. \$\endgroup\$ Commented May 30, 2022 at 4:20
  • 1
    \$\begingroup\$ @thejonymyster how specfically \$\endgroup\$ Commented May 30, 2022 at 4:23
  • \$\begingroup\$ IMO: Could summarize the whole feature-set up front, rather than introducing each feature one at a time. +-<> on their own are simple enough to have a sentence or two for, maybe some small examples alongside the explanations for ^v and how they interact with <>, and then some more complex test cases all lined up in a single code block at the end. Also, the line breaks are bulky and not necessary here. \$\endgroup\$ Commented May 30, 2022 at 4:28
0
\$\begingroup\$
--\/--
--/\--

Morse Tangles: ASCII Art

Given a word (with only letters, case insensitive), say SOS:

  • Change the word into Morse code, in this case, ... --- ...

  • Change dots to parallel bars and dashes to tangles.

Output the result as ASCII art:

------  \/\/\/  ------
------  /\/\/\  ------

Note that the spaces are two characters wide. This is .

Morse Code Chart:

https://cdn.shopify.com/s/files/1/2223/4507/files/morse-chart_grande.png?v=1501447409

\$\endgroup\$
3
  • \$\begingroup\$ Please, add a morse code table to the post for reference and provide some more test-cases. Please consider changing overline ¯ to a dash - as it's outside of ASCII range and that may exclude some languages from participating. I also suggest changing underscores to - for more golfing opportunities and removing the spaces between characters in the final tangle. \$\endgroup\$
    – pajonk
    Commented May 30, 2022 at 10:21
  • \$\begingroup\$ Done @pajonk .. \$\endgroup\$ Commented May 31, 2022 at 0:27
  • \$\begingroup\$ IMHO the Morse code table is short enough to be posted verbatim in the question (e.g. as a code block for easy copying) to make the question self-contained. Also, again, please add some more test-cases. \$\endgroup\$
    – pajonk
    Commented May 31, 2022 at 4:20
0
\$\begingroup\$

Extracting nth character of FizzBuzz

I was inspired by the challenge to output FizzBuzz as fast as possible. I have written and optimized some code to the degree that it computed the 10^1000000th character of FizzBuzz within 5 minutes (it's "7"). (Not the 10^1000000th line, this is the 10^1000000th character, and I don't mean 1000000, I really mean 10^1000000). See here. I'm not sure how the challenge would work, perhaps it could be "how fast can you extract the nth digit of FizzBuzz, where n is a random number with a million digits"? Or perhaps a simple king of the hill for "what's the furthest power of ten index you can compute"? I wonder if someone can up that to 10^10000000?

\$\endgroup\$
2
  • \$\begingroup\$ codegolf.stackexchange.com/questions/219009/… \$\endgroup\$
    – emanresu A
    Commented Jun 3, 2022 at 5:27
  • \$\begingroup\$ Thanks! But, that is just for the shortest code, rather than the most performant, or the highest character index computed. I commented my approach anyway though! \$\endgroup\$
    – lurf jurv
    Commented Jun 3, 2022 at 6:12
0
\$\begingroup\$

Rational numbers


Challenge

Every rational numbers (can be written in a fraction form \$a / b\$ ( \$a\$,\$b\$ are integers)) can be represent as a periodic, repeating decimal number.

For example, \$1 / 3\$ is \$0.3333333333333333...\$, so we represent it as \$0.(3)\$. Another example, \$3227 / 555\$ is \$5.8144144144...\$ so we represent it as \$5.8(144)\$.

Your task is, given a fraction \$a / b\$, print out its periodic, repeating decimal number,

Input/Output

  • Input/Output can be taken in any resonable format, containing the fraction.

Testcase:

5/2 -> 2.5(0)
1/3 -> 0.(3)
3227/555 -> 5.8(144)
557/495 -> 1.1(25)
35/17 -> 2.(0588235294117647)

This is , so so shortest answer (in bytes) wins!

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

Infinite Prisoner's Infilemma

Introduction

In this challenge, you are going to write a program that will play the game of the Infinite Prisoner's Infilemma.

This game is based on the classic game of the name Infinite Prisoner's Dilemma .

The original inspiration for this game came from this game by Nicky Case.

By default we will include the sample bots from Nicky Case's game. You can also add your own bots.

How to Play

Given a list of bot models [1,2,3,4,5]:

  • First, multiply the list by 10 to get 10 bots of each model.
  • Then, battle every two bots together.

During a battle there will be 10 rounds. Each round:

  • Both players will enter x dollars into a machine, where x is non-negative (not neccessarily an integer) and less than or equal to the amount of money they have. They start with $100.
  • The other player will recieve 1.1 times the amount of money.

Default Bots

Default bots are:

  • Copycat, which starts by cooperating with 1/3 of his money, and then cooperates with the same ammount of money as the ammount of money you cooperated last turn. (Unless he doesn't have enough money, which he will use all of them).

  • AlwaysCheat, which, always cheats by giving no money. DUH!

  • AlwaysCooperate, which, always cooperates by giving 1/2 of his money.

  • Grudger, which starts by cooperating with 1/3 of his money but gives no more money if you have ever cheated and give less than $10.

  • Detective, which cooperates $20, $5, $10, but if the opponent always gave at least $50, will act like an AlwaysCheat, else will act like a Copycat.

  • Copykitten, which is similar to Copycat, but cooperates with the same ammount of money as the max of the opponent's last two turns.

  • Simpleton, which starts by cooperating 1/2 of his money, then at every turn, if the opponent gave less than $20, switch a state between 1/2 of his money and none.

  • Random, which give, randomly, 2/3 to none of his money.

Instructions

Your bot should be a class. It will inherit from this Bot class:

class Bot:
    def __init__(self):
        self.money = 100
        self.information = {}

    def log(self, bot, money):
        if bot not in self.information:
            self.information[bot] = [money]
        else:
            self.information[bot] += [money]

    def change_money(self, money):
        self.money += money

    def choice(self, bot):
        pass # override in subclass

    def name(self):
        pass # should return the name of the bot

    def get_choice(self, bot):
        choice = self.choice(bot)
        assert 0 <= choice <= self.money, \
            f"Invalid choice {choice}, bot money {self.money}" # check if choice is valid
        return choice

You may not use any other libraries other than math and random. (If you have any requests, let me know. I mainly want to ban the use of inspect, sys, and os.)

You may also not override any methods other than choice and name.

You may not set self.money. (Else, you can come up with self.money = 10000, etc.)

The following is a sample bot:

from main import Bot # <-- import the Bot class
from random import random as r # <-- import the random function

class TestBot(Bot): # <-- create a class called TestBot
                    # <-- that inherits from Bot
    def choice(self, bot): # <-- override the choice method
        return self.money*r()/10 # random number between 0 and
                                 # 10% of the bot's money
    def name(self): # <-- override the name method
        return "randombot" # <-- return the name of the bot

bot = TestBot # <-- IMPORTANT: create a variable called bot

The Information Log

Well, sometimes you want to know what the opponent did. Thus, sometimes you need the "information log", called via self.information. Remember the bot argument that is passed in the choice method? That is your opponent. To get the information log of your opponent, use the following:

self.information[bot] # <-- get the information log of the opponent

What does that information look like? Well, it's like [[Y1,O1],[Y2,O2],...]. Y1 is what you gave the opponent in round 1. The rest is fairly easy to infer.

Controller Script

# This is the controller script for the Infinite Prisoner's Infilemma King of the Hill game.

bots = ['testbot','randombot'] # Will change.

# to make it fold-able.
if True:

    from rich.console import Console
    from rich.table import Table
    console = Console()
    with open('log.txt','w') as f: pass

    def print(*args, **kwargs): console.print(*args, **kwargs)

    def log(*text):
        with open('log.txt','a') as f:
            f.write(' '.join(list(map(str,text)))+'\n')

    def play(Bot1, Bot2):
        log(Bot1.name(), 'vs', Bot2.name())
        b1_choice, b2_choice = Bot1.get_choice(Bot2), Bot2.get_choice(Bot1)
        Bot1.change_money(-b1_choice)
        Bot2.change_money(-b2_choice)
        log(b1_choice, b2_choice)
        Bot1.change_money(1.001*b2_choice)
        Bot2.change_money(1.001*b1_choice)
        log(Bot1.name(), 'has', Bot1.money, 'dollars')
        log(Bot2.name(), 'has', Bot2.money, 'dollars')
        Bot1.log(Bot2, b1_choice, b2_choice)
        Bot2.log(Bot1, b2_choice, b1_choice)
        log('\n\n')

    class Bot:
        def __init__(self):
            self.money = 100
            self.information = {}

        def log(self, bot, money):
            if bot not in self.information:
                self.information[bot] = [money]
            else:
                self.information[bot] += [money]

        def change_money(self, money):
            self.money += money

        def choice(self, bot):
            pass # override in subclass

        def name(self):
            pass # should return the name of the bot

        def get_choice(self, bot):
            choice = self.choice(bot)
            assert 0 <= choice <= self.money, \
                f"Invalid choice {choice}, bot money {self.money}" # check if choice is valid
            return choice

    def leaderboard(Bots):
        table = Table(show_header=True, header_style="bold #00ffff")
        table.add_column("Bot", style="bold #ffff00") # yellow
        table.add_column("Money", justify="right", style="#00ff00") # green
        for bot in sorted(Bots, key=lambda x:-x.money):
            table.add_row(bot.name()+'     ',
                          f"     ${str(round(bot.money,2)) if str(round(bot.money,2))[::-1][1] != '.' else str(round(bot.money,2))+'0'}")
        print(table)

    def main():
        print('\n\n\n')

        Bots = []
        for bot in bots:
            for i in range(10): Bots.append(__import__(bot).bot())

        for Bot1 in Bots:
            for Bot2 in Bots:
                if Bot1 is not Bot2:
                    for i in range(10): play(Bot1,Bot2)

        leaderboard(Bots)
        print('\n\n\n')

    if __name__ == '__main__':
        main()

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

Compute the cophenetic correlation coefficient

Meta question at the end.

Background

The cophenetic correlation coefficient is used in bioinformatic to measure how close the distances of a tree are to the distances of the original distance matrix.

It is defined as follows: \${\displaystyle c={\frac {\sum _{i < j}(D_{ij}-{\bar {D}})(T_{ij}-{\bar {T}})}{\sqrt {\sum _{i < j}(D_{ij}-{\bar {D}})^{2}\sum _{i<j}(T_{ij}-{\bar {T}})^{2}}}}}\$

More information:

Input:

  • D: CSV style-string to first matrix
  • T: CSV style-string to second matrix

The input have the following format:

Eg 1: D.dist

N31
B14A.0, 2.0
N20, 3.0, 4.1
N20S, 12.0, 23.9, 4.3
EES.0, 10.3, 19.0, 16.0, 17.0
S2.0, 201.1, 99.6, 233.0, 297.0, 281.00

Eg. 2: T.dist

N31
B14A.0, 1.7
N20, 3.9, 4.1
N20S, 32.0, 25.1, 4.3
EES.0, 12.3, 19.5, 16.1, 17.1
S2.0, 202.2, 105.6, 227.1, 281.1, 283.5

The first column is a for us uninteresting identifier, the values (floats) are separated by a ,.

Output:

The cophenetic correlation coefficient.

Example:

Using the two matrices from above: 0.9982682565

Meta

Is it okay to use a file path as input? Or should I reformulate this question to input two matrices directly?

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

Don't like the middles

There will be no winner on these question. Just for the fun of the challenge.

Your job will be to output every sequence of each 10 numbers, alternating between the evens and odds, but removing the middle number, which means all numbers terminating in 4 or 5 must not be generated.

Here it goes exemplified for the first elements:

0 2 6 8
1 3 7 9
10 12 16 18
11 13 17 19
...

It is not mandatory you need to pretty format or have a list of sub-lists as shown here. One list or a string where each element is clearly separated from the previous and the next ones is enough.

\$\endgroup\$
1
  • 4
    \$\begingroup\$ Objective scoring criteria don't make challenges less fun; they're what make a challenge a challenge. They're also mandatory :P \$\endgroup\$ Commented Jun 13, 2022 at 20:34
0
\$\begingroup\$

Perform division for fuzzy numbers

Objective

Given two positive "fuzzy" numbers (as defined below), perform division between them.

Definition

Here, a fuzzy number consists of two integers: \$n\$ and \$r\$. It indicates that the number is from a measurement, and thus may carry an error. The measured number is \$n×2^r\$, and the maximum error is \$2^{r-1}\$.

In other words, the pair \$(n,r)\$ indicates that the exact number can be any of those from \$n×2^r - 2^{r-1}\$ and \$n×2^r + 2^{r-1}\$. As per the rounding convention, the boundaries are inclusive if \$n\$ is even, and exclusive if \$n\$ is odd.

In this challenge, only positive fuzzy numbers shall be considered. In other words, \$n\$ shall be positive.

Operation

Here, the operation in concern is division. Performing \$(n_1,r_1) ÷ (n_2,r_2)\$, the exact result of division is within the range from \$(n_1×2^{r_1} - 2^{r_1-1})/(n_2×2^{r_2} + 2^{r_2-1})\$ to \$(n_1×2^{r_1} + 2^{r_1-1})/(n_2×2^{r_2} - 2^{r_2-1})\$, where boundaries are inclusive if and only if both \$n_1\$ and \$n_2\$ are even.

The range indicated by result \$(n,r)\$ shall cover the range above as precisely as possible. That is, \$r\$ must be as small as possible. As a tiebreaker, the range must be as accurate as possible. That is, \$n\$ must be chosen so that \$n×2^r\$ would be as near as possible to: $$ ½((n_1×2^{r_1} - 2^{r_1-1})/(n_2×2^{r_2} + 2^{r_2-1}) + (n_1×2^{r_1} + 2^{r_1-1})/(n_2×2^{r_2} - 2^{r_2-1})) \\ =(4n_1n_2+1)/(4n_2^2-1)×2^{r_1-r_2} $$

For ranges with equal radii, those excluding boundaries shall be considered preciser than those including boundaries. This ensures uniqueness of the result.

Ungolfed solution

(WIP)

\$\endgroup\$
1
  • 1
    \$\begingroup\$ I think apart from unglofed solution (WIP, but I'm not a fan of posting reference implementations in a question) and some test-cases, there should be at least one or two thoroughly worked out examples. Also, please remember about specifying an objective scoring criterion and I/O requirements (if any). \$\endgroup\$
    – pajonk
    Commented Jun 23, 2022 at 12:28
0
\$\begingroup\$

I X the source code, you Y the output!


There's a zillion challenges of the form "I [do a thing to] the source code, you [do a thing to] the output!", like I double the source, you double the output! and I reverse the source code, you negate the output!. In this challenge you'll generalize that, writing a program that, given two functions x and y, will print a program p which prints some output o, with the property that x(p) prints y(o).

Task:

Your program (or function) should take two inputs, x and y, which can either be functions/lambdas, strings containing code, or some similar representation of a function in your language. You can assume these functions are pure: they have no side effects and do not depend on anything aside from their input. Other reasonable assumptions may be made based on your language's requirements, such as the input to x being a string of a certain length.

Your program should then print or return a program p, once again either as a pure lambda function (so it can't rely on x and y in the scope above it), a string representation of a program, function, or snippet, or some similar representation, such as writing an executable to a file. When p is run, it should take no input, and produce a deterministic value o. When x(p) is run, a second program will be produced, which, when run without input, should produce y(o) deterministically.

You may assume the data type of y(o) is the same as o, and make any other reasonable assumptions for your language. You may use any consistent data type for o, as long as it can hold more than 128 or so values (ints, floats, or strings would be preferred).

Sandbox:

This would be a very difficult challenge, and I'm not entirely sure what it would involve to answer or if it would even be possible to do so. I'm going to have to make some additional rules I think. maybe the inverse of x would be another input, that sort of thing. Feel free to suggest any ideas for rules to make this more possible and/or interesting, including across languages.

\$\endgroup\$
4
  • 1
    \$\begingroup\$ what if x is, say, return ""? or something else disruptive like z=>return "exitprogram()"+z \$\endgroup\$ Commented Jun 27, 2022 at 15:49
  • 1
    \$\begingroup\$ If x is an arbitrary function, this is impossible. Consider x being the identity function: p and x(p) are the same, so their outputs must be the same (since they must be pure and deterministic). For almost all y (in fact, all y except the identity function), this becomes impossible. You'd have to put some kind of very strong restriction on x for this to be doable, which I don't think can make it an interesting challenge. Either that, or allow solutions to be uncomputable (...cont'd) \$\endgroup\$
    – pxeger
    Commented Jun 27, 2022 at 16:03
  • \$\begingroup\$ (...cont'd) (A "valid" but uncomputable solution could be of the form: generate every program p and compute x(p), and check that y(eval(p)) == eval(x(p))). Some more (less trivial) logic can be used to show that this is also impossible if y is an arbitrary function. \$\endgroup\$
    – pxeger
    Commented Jun 27, 2022 at 16:03
  • 1
    \$\begingroup\$ @pxeger Yes, it's not possible with a number of xs and ys. I don't think restricting it so that it's possible makes it less interesting though. \$\endgroup\$ Commented Jun 27, 2022 at 16:29
0
\$\begingroup\$

Interleavable programs (WIP)

Your task in this challenge is to create programs that can be interleaved. Submissions will be in the form of collections of programs. The score for each collection is 2 raised to the power of the number of programs in that collection, and your total score is the sums of the scores of all the submitted collections. Here are the rules for each collection:

  • There must be at least 2 programs in each collection
  • The programs in the collection must be ordered from 1 to \$n\$
  • The \$n\$th program must output the integers in the range \$(i-1)*n\$ to \$i*n\$. Output can be as a list or string with separators (the separator can be an empty string)
  • When your programs are interleaved, their output is also interleaved
  • Programs can be reused in other collections

Example answer, score = 12

Collection 1:

  1. abcdef
  2. 123
  3. jklom

Interleaved: a1jb2kc3ldoemf

Collection 2:

  1. abcdef
  2. 123

Interleaved: a1b2c3def

Questions for Meta

  • How do I make the description clearer? It's not great right now.
  • Is this a dupe?
  • Should the output be modified so it's easier? Maybe people can choose their own output?
  • Any way to improve the scoring? How do I prevent people gaming the score by posting answers with lots of collections of size 2? I was thinking about forcing all programs in all collections to be drawn from the biggest collection.
  • Is this even worth posting as a question?
\$\endgroup\$
0
\$\begingroup\$

Input program generating Fibonacci, output program generating Fibonacci

Challenge:

You will have to write program, which outputs program, that outputs single Fibonacci number. First program should output first element of sequence (0), second should output second element of sequence (1), etc. You can also write two input strings - first is input to your program when it is first launched. Second will be always input to the generated program. The next time your program is launched, it's input will be the program it generated previously.

Rules:

  • Your score is sum of length of program and input strings.
  • Your inputs can be something else than string (numbers, booleans). To get your score, treat them like strings. E.g. true have length 4, 123,false have length 9.
  • You can use two different languages for the programs, but solutions using single language are preferred.

Output sequence (A000045):

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, ...

Related

\$\endgroup\$
3
  • \$\begingroup\$ "write two input strings", maybe "take two input strings"? \$\endgroup\$
    – tsh
    Commented Jul 11, 2022 at 6:02
  • \$\begingroup\$ "that outputs single Fibonacci number" do I required to output 0 for first outputted program, and 1 for the second one, ...? Or maybe I can always output 0 since it is a "Fibonacci number"? \$\endgroup\$
    – tsh
    Commented Jul 11, 2022 at 6:04
  • \$\begingroup\$ @tsh I made edit to address your second comment. Also I think that "write" as well as "take" is correct. But I wanted to say that this challenge is not just about writing program which you submit to your answer, but you can also write the input which counts towards byte count and is also part of your answer. \$\endgroup\$
    – Jiří
    Commented Jul 11, 2022 at 15:17
0
\$\begingroup\$

Make an ASCII art arrow

Given a size and direction (up, down, left, or right), you will create an ASCII art arrow.

Drawing it

For an arrow pointing up

For size \$s\$, there are \$2s\$ | characters in the center, with 1 _ character at the top. On the left of each of the top \$s\$ pipe characters, there is a / diagonally aligned with the arrow, and on the right side, the same but with backslashes.

Size 1:
 _
/|\
 |


Size 2:
  _
 /|\
/ | \
  |
  |

An arrow pointing down

Similar to an arrow facing up, it will have \$2s\$ (where \$s\$ is still the size) vertical | characters, with a hyphen below them. Starting from the bottom |, diagonally distribute slashes and backslashes on each side (only going up \$s\$ | characters).

Size 1:

 |
\|/
 -


Size 2:

  |
  |
\ | /
 \|/
  -

An arrow pointing left

Where \$s\$ is the size, there should be \$2s\$ hyphens going horizontally, with 1 | on the left of them. Starting from the leftmost hyphen, going up to the \$s\$th hyphen, diagonally distribute / and \ spreading out.

Size 1:

 /
|--
 \

Size 2:

  /
 /
|----
 \
  \

An arrow pointing right

This is pretty much an arrow pointing left, but inverted.

Where \$s\$ is the size, there should be \$2s\$ hyphens going horizontally, with 1 | on the right of them. Starting from the rightmost hyphen, going to the \$s\$th last hyphen, diagonally distribute / and \ spreading out.

Size 1:

 \
--|
 /

Size 2:

  \
   \
----|
   /
  /

Rules

  • As for the size, you may take any of \$n-1\$, \$n\$, \$n+1\$, or \$2n\$.
  • For the direction, you may use any four consistent values.
  • This is , so shortest code for each language wins.
  • Standard loopholes are forbidden.
  • Standard I/O rules apply.

Meta

  • Is this clear?
  • Is this too boring, or too similar to another challenge?
\$\endgroup\$
3
  • \$\begingroup\$ Related. \$\endgroup\$
    – naffetS
    Commented Jul 12, 2022 at 18:04
  • \$\begingroup\$ Suggestion: make the arrows "pointy" (with ^v<>) - this may however make the challenge harder as would prevent simple reflection of up/down and right/left pairs. \$\endgroup\$
    – pajonk
    Commented Jul 12, 2022 at 19:09
  • \$\begingroup\$ @pajonk I didn't do that because it looked fine on the up/down ones, but with left/right, it just looked really weird. \$\endgroup\$
    – naffetS
    Commented Jul 12, 2022 at 20:08
0
\$\begingroup\$

Get string from CIGAR and reference

In the field of genomics, CIGAR (Concise Idiosyncratic Gapped Alignment Report) strings are sometimes used to indicate how a DNA sequence aligns to a reference sequence of DNA. CIGAR strings are sequences of <operation, length> pairs. An operation can be M, meaning "match", I, meaning "insert", or D, meaning delete. The length describes the number of times the operation is repeated1. (For our purposes, we'll assume a match means that both matched characters are the same -- i.e. an alignment match.)

Suppose we align string \$S\$ to reference string \$R\$, producing CIGAR string \$C\$. You can think of the CIGAR string \$C\$ as operations applied to \$R\$ to turn it into \$S\$. If we treat \$R\$ as a sequence of consumable tokens, then to get \$R\$:

  • Iterate through the pairs <operation, length> in \$C\$:
    • length times, repeat operation:
      • If operation is I, output a character different than the current token of \$R\$
      • If operation is D, consume the current token of \$R\$
      • If operation is M, consume and output the current token of \$R\$

(Note: You can assume that for any input CIGAR string, all tokens in \$R\$ will be consumed. In other words, the length of \$R\$ equals the number of M and D operations applied.)

For example, suppose we've aligned the DNA string ACAACTA to the reference ACTCAGTA as follows:

AC-AAC--TAC 
ACT--CAGTAC
MMDIIMDDMMM

This would be encoded as M2D1I2M1D2M3.

Another example:

-G-T--G-AT--GGCG-T
AGCTGCGCATAA-GC-A-
DMDMDDMDMMDDIDDIDI

Which is encoded as D1M1D1M1D2M1D1M2D2I1D2I1D1I1.

The challenge: Given the reference string \$R\$ and a CIGAR string \$C\$, output a string \$S\$ which would produce the CIGAR string \$C\$ when aligned to \$R\$. (There are obviously many cases where there are many possible strings which satisfy this condition -- you can output any one of them.)

Test cases:

\$R\$ \$C\$ \$S\$
AAA M3 AAA
AAA I3D3 CCC
AAA D3I3 CCC
AAA D1I1D1I2D1 CCC
AAA D3 (the empty string)
AAA M1D2I1 AC
ACTCAGTA M2D1I2M1D2M3 ACAACTA
AGCTGCGCATAAGCA D1M1D1M1D2M1D1M2D2I1D2I1D1I1 GTGATGGCGT

Standard loopholes are forbidden. Because this is , the shortest program wins.

1Paraphrased from https://www.ebi.ac.uk/about/vertebrate-genomics/software/exonerate-manual

Questions

The more obvious question would be "given reference \$R\$ and aligning string \$S\$, find the cigar string corresponding to the best possible alignment", but that probably has been done already, and I've already accidentally posted a duplicate question...

I almost certainly should explain alignment better, but I'm not sure how to do it.

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

Generate number set with conditions using n numbers

\$\endgroup\$
3
  • \$\begingroup\$ Is this the same as "generate \$T=\{T_1, ..., T_x\}\$, the minimum number of \$k\$-length subsets of \$\{1,...,n\}\$ such that every \$v\$-length subset of \$\{1,...,n\}\$ is a subset of some set in \$T\$"? \$\endgroup\$ Commented Jul 29, 2022 at 20:31
  • \$\begingroup\$ @Adam yes It is same ? Has this been asked already? Or do you want me to change description to this ? \$\endgroup\$
    – 2FaceMan
    Commented Jul 30, 2022 at 5:30
  • 1
    \$\begingroup\$ For future reference a quote from the main sandbox post above: "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." Some of the issues raised in the main site could have been caught and addressed here. \$\endgroup\$
    – pajonk
    Commented Jul 30, 2022 at 18:04
0
\$\begingroup\$

Transform characters of your choice into "Hello, world!"

\$\endgroup\$
4
  • \$\begingroup\$ "takes character as input and outputs character", does it mean that the program output a single character? "fed into the program one by one", does it mean that the program take all 13 characters as input? If the program cannot store data between runs, how could it yield different output for same input? \$\endgroup\$
    – tsh
    Commented Jul 11, 2022 at 6:00
  • 1
    \$\begingroup\$ @tsh you get to choose which 13 characters are input. so you could, for example, have it so that inputting each of "abcdefghijklm" outputs a character of "Hello, world!". Every other character input would just have to output a character, with no further restriction. \$\endgroup\$ Commented Jul 11, 2022 at 12:47
  • 1
    \$\begingroup\$ I suspect in most languages it would be optimal to write a program which outputs its input, and use "Hello, world!" as the input, which isn't particularly interesting \$\endgroup\$ Commented Jul 18, 2022 at 3:59
  • \$\begingroup\$ @CommandMaster This is why I chose that it have to be unique characters, so cat program can't be used anymore. (character o is there two times, character l three times) \$\endgroup\$
    – Jiří
    Commented Jul 18, 2022 at 13:03
0
\$\begingroup\$

For Meta

This challenge is currently just a very undeveloped idea I had today! So I'm just dumping it here to start getting feedback and somewhere to leave my own thoughts and notes as I start this.

As this is in such a undeveloped form and I'm not sure when I'll have time to do it, other people are very much encouraged to develop this if they want!

I'm hoping to end up with something with a similar format to @trichoplax's Formic Functions - Ant Queen of the Hill Contest.

Notes

  • even a simple chess engine may be so complex that even expert golfing may have no effect on catching a better written engine in size
  • scoring seems very messy if you include game_length and function_length as these numbers could be all sorts of sizes
  • would checkers be a better/simpler game to do this with?
  • making it single language (javascript) would make it very easy to implement for me but would make golfing less interesting?

The Code Golf Chess Invitational

I have developed a simple chess interface (to be written) that will:

  1. provide board state to your function
  2. wait for your functions move
  3. verify your move
    • invalid moves will result in a loss
  4. make the move
  5. repeat for the opponent
  6. and repeat until there is a winner
  7. then score both functions

The score

The score of each function will be determined by the length of each function and the number of moves the game lasted. With higher scores being worse!

  • Winners score will be 1 * length_of_program
  • Losers score will be game_length * length_of_program
  • Losing by invalid move score will be (game_length)^2 * length_of_program

(Scoring very much to be revised but ideally I want to encourage short programs, encourage winning, and absolutely discourage invalid moves (random playing))

Your function

  • MUST NOT query other sites/libraries/etc
    • it could include an entire library if you wished, but that would obviously be a very long function
  • should take a 2d array as input of the board state, [[a1, a2 ... a8], [b1 ... h8]]
  • return a chess move in chess notation
  • warnings (and errors?) are fine as long as the program still returns a move
  • normal other restrictions apply

You, yourself

  • Please provide assistance in getting your function running on the GitHub site!

(this needs work because whilst I'm sure I could get many common languages (esp scripting languages) working I'm not sure how well I'd do with some of the more golf-y/compiled languages)

Tournament

The initial tournament would be a continuous round robin of all current submissions with each functions running score an average of each score each game.

Then a final day, where every function competes against every function x times. This would decide the "winner" of the competition and the accepted answer tick.

Then just for fun a seeded knockout tournament (based on the final score) to decide who had the best chess program. (Maybe a bounty award for this)

\$\endgroup\$
1
  • 2
    \$\begingroup\$ I think you should make winners score 0 and losers (including invalid moves) length_of_program+10 or something similar. Because currently the best strategy is to lose game at beginning by invalid move. Anyway, if you decide my idea of scoring isn't good enough, then it feels weird to punish losers for long games - I expect that longer games are harder and shorter games are simpler, so the scoring should be opposite. \$\endgroup\$
    – Jiří
    Commented Aug 4, 2022 at 15:59
0
\$\begingroup\$

Implement Bloom filter insertion

A Bloom filter is a probabilistic data structure that is used to determine whether an element is in a set in a fixed number of bits. It consists of:

  1. a bit array \$B\$ of fixed size \$m\$, initialized as all \$0\$s, and
  2. \$k\$ different hash functions \$h_1,\ldots,h_k\$ which each map any element to some value \$v \in 0,\ldots,m-1\$.

To insert element \$s\$ into the set, set \$B[h_i(s)]\$ to \$1\$ for each hash function \$h_i\$.

To check if element \$s\$ is in the set, check the value of \$B[h_i(s)]\$ for each hash function \$h_i\$. If they are all \$1\$, return true; otherwise return false.

For example, suppose we start with bit array of size 5:

0 0 0 0 0

We also define hash functions \$h_1(s) = s\bmod m, h_2(s) = (s^2)\bmod m\$. To insert value \$13\$, We calculate the indices to change: $$i_1 = h_1(13) = 13\bmod 5 = 3,\\ i_2 = h_2(13) = (13^2)\bmod 5 = 4$$ So we set \$B[3]\$ and \$B[4]\$ to \$1\$:

0 0 0 1 1

To check if \$13\$ is in the set, we look if \$B[3]\$ and \$B[4]\$ are both \$1\$.

The challenge

You should implement the insertion part of a Bloom filter. Take in three inputs: two positive integers \$m\$ and \$k\$, and a series of non-negative integers \$S=\{s_1, \ldots, s_n\}\$. Output the bit array of the Bloom filter of size \$m\$ with all the elements of \$S\$ added using \$k\$ hash functions, with any two distinct values substituting for \$1\$ and \$0\$.

You can choose any \$k\$ hash functions as long as they have uniformly distributed output and are not perfectly correlated (probably the wrong term for this). In other words:

  • Over all non-negative integers \$\{s\}\$, the probability of \$h_i(s)=v\in\{0,\ldots,m-1\}\$ is \$\frac1m\$.
  • For all pairs of functions \$(h_i,h_j)\$, there is not a mapping between the output of \$h_i\$ and the output of \$h_j\$. For example, you couldn't use \$h_1(s) = s\bmod m, h_2(s) = (s+1)\bmod m,\$ because you can perfectly determine the output of \$h_2\$ from the output of \$h_1\$.

(Ideally, these functions should be independent, but that's not a practical request.)

Examples

TODO

Questions

I could ask for both insertion and value checking, but I don't want to overcomplicate this.

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

All permutations of range from \$1\$ to \$n\$

Given a positive input \$n\$, output all permutations of either \$\{0,1,\ldots,n\}\$ or \$\{1,2,\ldots,n\}\$.

Examples

Outputting permutations of \$\{1,2,\ldots,n\}\$.

Input Output
1 [(1)]
2 [(1, 2), (2, 1)]
4 [(1, 2, 3, 4), (1, 2, 4, 3), (1, 3, 2, 4), (1, 3, 4, 2), (1, 4, 2, 3), (1, 4, 3, 2), (2, 1, 3, 4), (2, 1, 4, 3), (2, 3, 1, 4), (2, 3, 4, 1), (2, 4, 1, 3), (2, 4, 3, 1), (3, 1, 2, 4), (3, 1, 4, 2), (3, 2, 1, 4), (3, 2, 4, 1), (3, 4, 1, 2), (3, 4, 2, 1), (4, 1, 2, 3), (4, 1, 3, 2), (4, 2, 1, 3), (4, 2, 3, 1), (4, 3, 1, 2), (4, 3, 2, 1)]

Standard loopholes are forbidden. The shortest code wins.

Questions

I was looking for this challenge, but I couldn't find it posted anywhere. Maybe because it's too derivative of a simple "output all permutations" challenge?

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

Hello, World! hashing

Implement a one-way hashing function that generates arbitrary strings which have a chance (obviously input dependent) of producing at least any of the printable ASCII characters when provided an input of at least 2 characters. This can be any mechanism you choose and could always output a fixed length if desired, however when your source code is used as input, the resultant output must be Hello, World!.

Rules

  • The input string will always be 2 characters or more (meaning your code must be at least two characters).
  • There are no other special requirements for any other input strings.
  • The output should not be exactly the same as the input (this might be unavoidable in some scenarios with well-crafted input, but you can't just output your input if the code Hello, World!, by some magic, in your language performs some sort of hashing).
  • It should be feasible to get at least any of the printable ASCII characters as output. You are however not limited to printable ASCII output and may output any combination of bytes (e.g. unprintables, UTF-8 sequences)
  • All characters of the input string should be taken into account when generating strings, not just the first 13 and should affect the output.

For meta

I'd really like to encourage answers that aren't a condition that just compares input with source and outputs Hello, World! in that instance, but as pointed out by @pajonk it's a non-observable requirement.

\$\endgroup\$
9
  • \$\begingroup\$ I think you can use tags code-golf, hello-world and restricted-source. Can you also explain what does "strings consisting of at least (but not limited to) the printable ASCII" mean? (That some strings have to contain printable characters or all strings have to contain printable characters?) Also does full input string have to be used to calculate hash? I expect some people might want to use just fixed part of input string to make this task easier. \$\endgroup\$
    – Jiří
    Commented Aug 2, 2022 at 16:10
  • 2
    \$\begingroup\$ Suggested tag: self-referential. Be careful with non-observable requirements (like you must not have a special condition), as they are discouraged. Also, you may define what does most inputs should result in different output mean exactly (or drop it), as this may be considered too vague. \$\endgroup\$
    – pajonk
    Commented Aug 3, 2022 at 7:12
  • \$\begingroup\$ @Jiří My intention with that wording is that the output you generate must at least have the possibility for any character in the printable ASCII range to be included, but may also output unprintables or higher byte value unicode chars for instance. The full input string must also be used, yes. So changing a character at the end of the string should change the value returned. I'll clarify that. Also, not entirely sure on restricted-source, but I'll check the wiki, thank you! \$\endgroup\$ Commented Aug 3, 2022 at 12:24
  • \$\begingroup\$ @pajonk Yeah, that's a good point. I guess I didn't want an arbitrary hashing algorithm with a if input == source condition (which I think would be considerably easier). Good point about the wording on most inputs I'll clarify along with Jiří's suggestion of ensuring all characters are used and can affect the output, hopefully that covers that off. I'll look at self-referential too. Thank you! \$\endgroup\$ Commented Aug 3, 2022 at 12:27
  • \$\begingroup\$ @pajonk I can't think of a way to make an observable requirement to avoid the simpler solution which makes me inclined to remove this as I think it trivialises the problem. Any idea on how to enforce that without having this blacklisted? \$\endgroup\$ Commented Aug 3, 2022 at 12:34
  • \$\begingroup\$ @DomHastings remember that simple comparison input==source is not so simple, as requires a modified version of a quine. This may or may not be shorter than other possible approaches. \$\endgroup\$
    – pajonk
    Commented Aug 3, 2022 at 12:45
  • \$\begingroup\$ Also I was thinking how I would write answer for this and came up with following idea: Sum all characters on input and then add this sum to ASCII codes of individual characters of string "Hello, World!" (%256). Would this answer be fine? \$\endgroup\$
    – Jiří
    Commented Aug 3, 2022 at 13:08
  • \$\begingroup\$ @Jiří yeah, absolutely! \$\endgroup\$ Commented Aug 7, 2022 at 13:26
  • \$\begingroup\$ @pajonk I guess so, I feel like modified quines aren't that interesting sometimes... But you're right, probably not trivial in every language. I guess the kinda of answer is love to see is a generic mechanism that is calculated to, based on the code as input, the exact string required, but that might be a big request! It's an interesting problem (to me at least) as it felt easier than I've found it upon trying to execute it! \$\endgroup\$ Commented Aug 7, 2022 at 13:29
0
\$\begingroup\$

Generate a Kirkman triple system

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

Program a compiler compiler

Write a program, function, or likewise that takes in a BNF-like grammar specification(see below) and outputs a program or function in a language of your choice that takes strings as input and returns truthy if that string is parseable with the specified grammar, and false otherwise.

Meta-language:

The input to your program will consist of a number of bnf-like rules. Each definition will be on its own line, and will consist of a name (string of 1 or more characters [a-z0-9]), followed by the symbol ::= followed by a string of symbols(terminal and non terminal), terminals consist of [a-zA-Z0-9() ]. Nonterminals are denoted with a < followed by a string of characters [a-z0-9] followed by >; that string of characters refers to another definition. Each definition may have multiple alternatives, separated by |. Alternatives should be matched left to right. The first line of the input will share this same form, except that it will not have the name of the definition or the ::=. This is the "top-level" definition that the input to the outputted program will attempt to be matched against.

Input grammars will never contain left-recursion (ie. it will never be the case that there will be a rule of the form a::=<a>). You may additionally assume that your generated program will only be given as input strings that contain only those characters comprising valid terminal symbol([a-zA-Z0-9() ]). Additionally, your compiler-compiling program only needs to handle valid definitions.

Examples:

The following should be handled appropriately by your program:

binaryliteral
binaryliteral::=0<binaryliteral>|1<binaryliteral>|0|1

This means that the generated program should return truthy for any strings that match the definition of a binary literal, which is either the character 0 or 1 followed by a binary literal, or just 0 or 1. This would recognize strings

quantexpr
quantexpr::=forall <var>(<expr1>)|exists <var>(<expr1>)
expr1::=<expr0> and <expr1>|<expr0> or <expr0> |not <expr1>|<expr0>
expr0::=<var>|(<expr1>)
var::=x|y|z

and you do not need to handle the following:

x:=1
expr
expr::=x|<expr> plus <expr>

As usual, this is code-golf, so the shortest program per (implementation, output language) pair wins!

\$\endgroup\$
3
  • \$\begingroup\$ This could use a bit of cleanup but I'm totally behind this idea, so +1. Note: i think your terminal string regex is wrong, +-* expresses a range. in general i think it'd be worth considering simplifying what terminals are allowed, but thats just my onpinioin \$\endgroup\$ Commented Aug 15, 2022 at 15:06
  • \$\begingroup\$ @thejonymyster good catch on that regex; I'll fix that. Is there anything else that needs to be changed pursuant to "cleaning up"? \$\endgroup\$
    – Benji
    Commented Aug 15, 2022 at 16:57
  • \$\begingroup\$ sorry for the nondescriptive wording on my part; I just think the meta language description could be broken down into smaller sections, maybe with a small worked-out example or two. As is, it's fairly clear but just a bit densely packed. Additionally, I think you should link to something (maybe wikipedia) about BNF, for those entirely unfamiliar. :-) \$\endgroup\$ Commented Aug 15, 2022 at 18:13
0
\$\begingroup\$

smallest number of steps for a knight in chess

\$\endgroup\$
1
  • 1
    \$\begingroup\$ I've edited this down to a stub now that it's been posted to save space \$\endgroup\$ Commented Aug 20, 2022 at 1:07
1
135 136
137
138 139
158

You must log in to answer this question.

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