Sandbox for Proposed Challenges

Question

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

Answer 1

Verify the Perfect Rectangle

According to Wolfram Mathworld, a perfect rectangle is defined to be a rectangle that can be divided into squares of different side lengths.

In this challenge, we are going to verify whether or not an arrangement is a perfect rectangle.

For the input, there should be at least 3n+2 non-negative integers in it:

• The first two numbers should show the size of the rectangle.
• Rest of the 3n numbers should describe n squares.
• Each square should be described with 3 numbers, which are the side length(>0) and the position(x, y).
• Position should be consistent throughout the whole input. For example, If the program gets the position of the bottom left corner of the square for one time, it should do that every other time as well.

For the output, the program should print a truthy value if the given arrangement is a perfect rectangle, and a falsey value otherwise.

• Every squares should be different in side length.
• There should be neither overlaps nor voids.

Test cases(Note that any input and output formats are acceptable if they are reasonable):

[[32,33],[9,0,0],[8,9,0],[15,17,0],[10,0,9],[1,9,8],[7,10,8],[14,0,19],[4,10,15],[18,14,15]]
-> True #This is the first example in the above link. 

[[65,47],[23,0,0],[17,23,0],[25,40,0],[6,23,17],[11,29,17],[24,0,23],[5,24,23],[19,24,28],[3,40,25],[22,43,25]]
-> True #This is the second example in the above link. 

[[4,4],[2,0,0],[2,2,0],[2,0,2],[1,2,2],[1,3,2],[1,3,3],[1,2,3]]
-> False #There are sqaures of same sizes. 

[[5,5],[3,0,0],[3,2,2],[2,0,3],[1,3,1],[1,3,0],[1,7,0]]
-> False #There are overlaps and voids. 

This is code-golf, which means that codes with least bytes win.

Answer 2

Create a non-renewable world

In Minecraft, we can split all possible items into two categories: renewable and non-renewable. All non-renewable items are simply items that are not renewable.

Minecraft worlds are not infinite, meaning that, for some resources, there are only a finite number available. This number is often huge, but it is finite. For example, diamond ore can only be obtained by mining blocks that are generated when the world is created, meaning that there is only a finite number of them in any given world.

However, some resources can be obtained infinitely. For example, as Raid Captains will spawn indefinitely, it is possible to obtain an arbitrarily large number of Ominous Banners, dropped when you kill a Raid Captain. Or, as you can create an infinite water source, and you can get infinite iron by killing Iron Golems, it is possible to get an infinite number of Water Buckets.

Any resource for which it is possible to obtain an arbitrary amount of is called renewable, and there are a lot of these. Any item that is not renewable is non-renewable. There are 40 of these that are obtainable in a classic Minecraft 1.16 survival world. They are:

A Netherite Tool               Netherite Armor                Ancient Debris                 Block of Diamond              
Block of Netherite             Coal Ore                       Cobweb                         Conduit                       
Dead Bush                      Diamond                        Diamond Ore                    Dragon Egg                    
Dragon Head                    Elytra                         Emerald Ore                    Enchanted Golden Apple        
Enchantment Table              Gilded Blackstone              Gold Ore                       Heart of the Sea              
Iron Ore                       Jukebox                        Lapis Lazuli Ore               Large Fern                    
Lava Bucket                    Lodestone                      Nether Gold Ore                Netherite Ingot               
Netherite Scrap                Iron/Gold/Diamond Horse Armor  Pigstep Music Disc             Quartz Ore                    
Redstone Ore                   Shulker Box                    Shulker Shell                  Snout Banner Pattern          
Sponge                         Tall Grass                     Thing Banner Pattern           Wet Sponge              

Your task is to get as many of these 40 items as you can. A Netherite Tool means any of a Netherite Sword, Pickaxe, Axe, Shovel or Hoe. Netherite Armor is any of a Netherite helmet, Chestplate, Leggings or Boots. Iron/Gold/Diamond Horse Armor means that any of these three are acceptable. Leather Horse Amor is not.

---

You should create a vanilla Minecraft Java Edition world, in 1.16.5, in Hardcore difficulty. You then have until you die in that world to collect all 40 of these items, or as many as you can. You should provide a double chest containing 1 of each of these and nothing else.

In order to verify attempts, you should provide the save file of your world, as a zip file.

The user who gets the most of these 40 items before dying wins. If multiple users get all 40 items, the user who gets all 40 within the fewest in-game days, which can be found by pressing F3.

Rules

• You may not change the game rules of the world from the default, nor may you change any other option during world creation aside from the seed. To be fully clear, you may change exactly 3 things from the default values after clicking "Create New World":
  • The name of the world
  • The gamemode, switching from Survival to Hardcore
  • Optionally, the seed, which may be any value of your choosing
• While in the world, you may not enable commands. This is typically done by pausing the game, opening the world to LAN and enabling commands, but, regardless of how you may do it, enabling commands is completely forbidden.
• You may not use any mods, datapacks or anything else that can modify the default behaviour of the game. Texture packs are perfectly fine.
• I will be testing and confirming each world submitted, so you should not include anything in the save file that isn't generated by the world. You may not edit the save file directly, only by interacting with the world
• Items are allowed to be enchanted, renamed or otherwise legitimately modified in game

---

Additionally, as of snapshot 21w20a, there are 18 new non-renewable resources (ignoring products from Deepslate and Cobbled Deepslate), and Lava Buckets are noew renewable:

Block Of Raw Copper        Block Of Raw Gold         
Block Of Raw Iron          Budding Amethyst          
Calcite                    Cobbled Deepslate         
Copper Ore                 Deepslate                 
Deepslate Diamond Ore      Deepslate Gold Ore        
Deepslate Iron Ore         Deepslate Lapis Lazuli Ore
Deepslate Redstone Ore     Raw Copper                
Raw Gold                   Raw Iron                  
Spore Blossom              Tuff     

This brings the total number of non-renewable items in the latest version to 57

I will offer a +500 bounty to a submission which also includes a save file for a world which:

• Is a vanilla Minecraft Java Edition snapshot 21w20a Hardcore world
• Meets the requirements for the main challenge
• Has 3 chests with all 57 non-renewable items, as listed above

---

Meta

• Is this clear enough?
• Are there any ways this can be exploited, so that users can trivialise the task? How can I prevent those exploits?
• Is it a good challenge?
• Tags are code-challenge, game and minecraft (meta discussion). Any suggestions?
• Minecraft is not free, thus limiting those who can compete. Is this a significant problem?
• Any further feedback?

Answer 3

for (a.length of a) code-golf array-manipulation javascript

A recent conversation in The Nineteenth Byte about language design brought about discussion of an "interesting" snippet of JavaScript code:

for (a.length of a) console.log(a)

This loops over the elements of a, but assigns each element to the length of a, and prints out a on each iteration.

• When an array's length is assigned, it is resized to the length, with excess elements being removed from the end, and additional elements filled with undefined
• When an array's length is assigned to undefined, an error occurs
• The loop will halt if the number of iterations is ever greater than a.length

Depending on the contents of a, this produces some wild results.

TODO: finish this post. Posted without finishing to test if Redwolf Program's Sandbox Posts bot is working :)

Answer 4

Given a black-box function f(x) which take a value x and output true for \$p(x)\$, an unknown continious monotone function(not knowing even whether it's increasing), probable; and false otherwise. Output an infinite sequence \$a_n\$ such that \$\lim_{n\rightarrow \infty}p(a_n)=0.5\$. You can assume that the result exists.

Reasonable I/O allowed. Shortest code win.

A possible solution:

for i=1..infty
    S = [i/2] * i*i*2
    for j=0..i*i*2-1
        for k=1..i
            if f(j/i-i)
                S[j]--
    print minPos([t*t for t in S])/i-i

Try It Online!

random code-golf

Answer 5

duplicate :(

Answer 6

Convert Lambda Calculus to SKI-notation

Lambda calculus is a formal system in mathematical logic for expressing computation based on function abstraction and application using variable binding and substitution.

However, it's possible to translate pure lambda calculus into SKI-notation. This can be preformed by building an AST for the lambda calculus, converting it through multiple substitution steps where it contains a mixture of lambda calculus and SKI-notation, until a pure SKI-notation expression is reached.

As this is code golf, there is some flexibility on your I/O so that you may be able to accept the lambda calculus and output the SKI-notation as a tree but the examples will use a string-based notation.

• (c1), where c1 is an arbitrary expression that does not contain a lambda (represented here by >), does not require further substitution.
• (c1(c2)), where c1 and c2 are arbitrary expressions, can be substituted with (s1(s2)), where s1 and s2 are the result of performing any necessary substitutions on c1 and c2.
• (x1>x1) can be substituted with I.
• (x1>c1) (where c1 can be an arbitrary expression as long as it does not contain a reference to x1) can be substituted with (Ks1), where s1 is the result of performing any necessary substitutions on c1.
• (x1>(x2>x1)) can be substituted with K.
• (x1>(x2>e1)) (where e1 is an arbitrary expression that is depends on but is not x1) can be substituted by performing substitutions on (x2>e1) resulting in s2 and then performing substitutions on (x1>s2).
• (x1>c1(e2)) (where c1 can be an arbitrary expression as long as it does not contain a reference to x1) can be substituted with (s1(s2)), where s1 and s2 are the result of performing any necessary substitutions on c1 and (x1>e2).
• (x1>e1(e2)) can be substituted with (S(s1)(s2)), where s1 and s2 are the result of performing any necessary substitutions on (x1>e1) and (x1>e2).

Naturally function application associates left-to-right, so in the case of (x1>c1(c2)(e3)(c4)) this needs to be substituted using the last rule as if it was (x1>(c1(c2)(e2))(c4)), which requires generating substitutions for (x1>c1(c2)(e2)) and (x1>c4), but then (x1>c1(c2)(e2)) can use the penultimate rule, turning into c1(c2)(x1>e2), with (x1>e2) still needing to be substituted.

Given an input expression of lambda calculus, please convert it to SKI-notation. You must use the above substitutions at a minimum, but you can perform additional reductions if you wish, so for instance if you use a string-based notation then you may simplify ((S)(K)) to (SK) or even SK depending on context.

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

Answer 7

Conic Sections (simplified)

code-golf math characteristics

---

Given the equation of a non-parabolic conic section, output its characteristics.

---

Spec

This assumes prior knowledge of hyperbolas and ellipses, as well as their characteristics. (This includes circles; they are a special case of the ellipse with eccentricity of zero.)

Input

A non-parabolic (to simplify things) conic section given in the standard equation form. To simplify things further (because the main point is not to perform linear algebra magic) there will be no xy term. This is an example of a valid equation:

x^2+6x+y^2-8y+15=0 // string form
[1,6,1,-8,15]      // array form

These are not:

x^3+5x^2+7x+4=0 // because the degree of the equation is 2
x^2+5xy+y^2-4=0 // because there should be no `xy` term
x^2+3x+7=0      // because there should be `x` and `y` terms.

Note that the conic section can also be taken as an array as shown above. If so, please specify the order of the array; I am flexible when it comes to this format, As long as there are 5 elements with nonexistent terms represented by zero (like no y term in x^2+5x+y^2+14=0) and that the terms they represent are x^2 x y^2 y c where c is a constant. The equation will always be <expression> = 0.

Output

Output should be the type of section, center, horizontal radius, vertical radius, foci and eccentricity (in whatever desired order). This can be output as a string or an array as long as it is clear. A valid output for x^2+6x+y^2+8y+16=0 (or its array equivalent) would be:

["ellipse", [-3, -4], 3, 3, [[-3, -4]], 0]

or

ellipse
-3 -4
3
3
-3 -4
0

or similar.

(no need to output "circle" because it is a special case of the ellipse)

Meta:

• duplicate?
• should I edit in info on conic sections?
• should I create the characteristics tag?

Answer 8

Is this a trivial brainfuck NOP? code-golf string decision-problem halting-problem brainfuck

Brainfuck is Turing-complete^*, which means determining the behaviour of an arbitrary program is undecidable. However, we can get arbitrarily close to this if we limit ourselves to detecting a limited subset of programs.

For this challenge, we will detect a limited subset of NOPs - that is, snippets of programs which have no effect including on the brainfuck interpreter's state - which I have declared "trivial NOPs".

Here is a recursive definition of a trivial NOP:

• the empty string is a trivial NOP
• snippets consisting only of characters outside the set []<>+-,. (that is, characters which are ignored in Brainfuck), are trivial NOPs
• the concatenation of two trivial NOPs is also a trivial NOP
• snippets of any of the following forms, where X is another trivial NOP, are also trivial NOPs:
  • +X-
  • -X+
  • <X>
  • >X<

We will assume brainfuck has unlimited tape length. Overflow also does not need to be considered, because if a cell rolls over due to a +, a - can then underflow it back and it will still be a NOP.

Any snippet containing , or . is not a NOP because it performs impure I/O, and any snippet containing [ or ] is undecidable, so must be assumed to be not a NOP.

Your task is to, given a brainfuck snippet as a string or list of characters, determine whether it is a trivial NOP, and output two distinct values corresponding to true and false.

Test-cases

Truthy

(empty string)
a
+-
<>-+
<!>
+<-+>-
<<<+++a+--++>><-+>>

Falsey

<+>+<->-             (note: even though this is a NOP, it's not a trivial NOP)
+<-+>-[]
,+<-+>-
<.>

Rules

• You may assume the input string always consists only of printable ASCII excluding space
• You may use any reasonable I/O method
• Standard loopholes are forbidden
• This is code-golf, so the shortest code in bytes wins

---

Meta

• Can you think of any other classes of brainfuck snippet that are simple to detect as doing nothing?
• Is this a duplicate?
• Is this clear enough?
• Any other feedback?

Answer 9

Back to the sandbox.

Challenge will be initially done on TBD, although I may do it again after that sometimes. Also, programs will be launched with a launcher shell script.

Background/story

You are a programmer who has been requested to create a program that wipes out other similar programs. However, you need to have your program fight others to see how it does in the field.

Requirements

You are to make a program that can run on a Debian 10 VM. If the language you use is not available by default on Debian 10, you must provide instructions or a link to the compiler.

Formatting

Submissions are to be formatted as follows:

# Name, Language

Description

```
Code
```

More description and explanation

Link to compiler download and/or download instructions for Debian 10 GNU/Linux (also add compiler options to use when compiling.)

Requirements for being included

Your answer must have at least one upvote. You also need to include an emergency off switch and test the switch to be included, and provide the source code and have tested it on a Debian 10 VM. Also, its growth rate must be hypothetically sub-exponential (this is to stop excessively laggy answers. If you don't know what growth rate to go with, go with linear (\$O(x)\$) or Polynomial (\$O(x^2)\$,\$O(x^3)\$,etc.).

Victory

To win, you need to be the last process of the bunch, by killing other processes through a system call. If you kill important processes that result in the VM breaking, that round is ignored for scoring. A total of 100 rounds will be run, and you get a point if you are the last "malicious" process around. If there's a tie, the tiers will be put in a tiebreaker.

Pseudocode for submission example

I don't know much about coding yet, so here's some pseudocode (feel free to convert it to a real programming language and mark it as such:

Example, Pseudocode

This program simply kills processes with the word "MalicousProcess", unless it's "MalicousProcess-Example"

def Example () {
  while (system(ps aux | grep "MalicousProcess") != null) {
    for each process != "MalicousProcess-Example" {
      kill process
    }
  }
  return 0

fictitious compiler

Please provide more recommendations.

Answer 10

Pickleball Doubles Scoring

Answer 11

What sequence? answer-chainingsequence

Stack Exchange distinguishes users by a unique id that can be found in their their profile URL.

You can find your id by navigating to https://codegolf.stackexchange.com/users/current and finding the number after the /users/ bit in the resulting URL. For example, my profile URL is https://codegolf.stackexchange.com/users/99744/alex-bries, so my user ID is 99744

You can use this id to look up the number sequence of the last submitter on OEIS:

The On-Line Encyclopedia of Integer Sequences® (OEIS) is an online database containing integer sequences. These sequences are identified via an id starting with an A followed by 6 numbers. You can search for an id with the "id:" key on the search bar of OEIS.
id:A99744 will display sequence A099744 followed by all other sequences that mention it.

Your job is to write a program that, when given a number n, produces the nth number in sequence of the submitter above.

Rules

• Each language may only be used once.
• You may not post 2 answers in a row
• Every next submision may only be max 10 bytes higher than the previous one
• The champion is the last valid submission on june 14th

golfing is not a requirement but it is in your favour

Answer 12

Write a program that mimics the output of the command env (with no arguments).

The program should print (to standard output, or closest equivalent) a list of all current environment variables, with each variable on it's own line. The name and content of a variable should be separated by an equal sign.

Here's a grammar:

line ::= name "=" contents
output ::= (line "\n")*

No using the env command, or any 1 command that completes the challenge on its own.

shortest code wins.

Answer 13

Optimize imnotdeadfish

Answer 14

branch golfing: sort a list by number of prime factors

Specifically, first sorted by total number of prime factors, with any ties broken by number of unique prime factors (remove this?), then broken by size. The list will never contain 1.

Test cases:

[4,5,6,9] -> [5,4,9,6]
[10,11,12] -> [11,10,12]
[360 200 12] -> [12 200 360]
[63 64 65] -> [65 63 64]

Answer 15

Random Prisoner's Trilemma - Python 3 KOTH

Answer 16

Yet another digit insertion problem

Answer 17

How much faster than qsort can you achieve?

Task

Sort 1 million 32 bit integers as quickly as possible. Your code must create 1 million random non-negative integers in the range 0 to 999999 and sort them. Only the sorting should be timed.

Score

I will run your code and compare the timings to my default C code using qsort. That is:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <stdint.h>


int cmpfunc (const void * a, const void * b) {
   return ( *(int*)a - *(int*)b );
}

int main(void) {
    int sz;
    srand(time(NULL));
    printf("Enter the size of array::");
    scanf("%d",&sz);
    uint32_t *arr = malloc (sz * sizeof(uint32_t));
    int i;
    for(i=0;i<sz;i++)
        arr[i]=rand()%1000000; 
    clock_t begin = clock();
    qsort(arr, sz, sizeof(int), cmpfunc);
    clock_t end = clock();
    double time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
    printf("%f seconds\n", time_spent);
    printf("%d\n", arr[10]);
    return 0;
}

Your score will be the timing for my C code divided by the timing for your code. I will run both on my PC. This means I will need clear instructions for how to compile and run your code on linux.

This means you will have to provide timing code in your solution so I am not timing the creation of the data.

Current timings

On my PC:

• The sample C code takes 0.11 seconds.
• Python sorted takes 0.24 seconds.

Notes

My code prints out one of the elements of the sorted array. This is to stop the opimizing compiler from removing the sorting code completely. You will have to do the same.

Builins are allowed. As ever this is a challenge per language so if your Python answer is faster than any other Python answer you have won that mini-competition. fastest-code

Answer 18

Smallest number of actions to change reputation by [x] points

8: Upvote + downvote

75: Bounty + upvote + accepted answer

Draft

Answer 19

Finite Composition of Univariate Functions math code-golf

Problem

Given $$\mathbb{F}:=\{f_i \mid f_i : \mathbb{R} \to \mathbb{R}\}$$ the set of all the real maps, and the n-ary function composition

\begin{gather} c_o(f_i) = f_1∘f_2∘f_3⋯∘f_n\\[8pt] ∀f_i ∈ \mathbb{F},~~~1≤i≤n∈\mathbb{N} \end{gather}

write a program which receives n functions of a real variable as the input and computes the in-order function composition, product of all the entered functions as a string.

As standard, x is the name of the parameter variable in each function. Any other literal is taken as a constant.

Examples

Example 1

input

number of functions: 3
f_1 = x + 1
f_2 = x - 10
f_3 = x^2 + 2

output

c_o(f_1,f_2,f_3) = ((x^2 + 2) - 10) + 1

Example 2

input

number of functions: 4
f_1 = 27x - sin(e)
f_2 = -7(x^2 + 1)^(1/2) 4y^3 + 21
f_3 = x^(3/2) + 4
f_4 = ln(z + 1)
(z, y, e are assumed as constants in the reals)

output

c_o(f_1,f_2,f_3,f_4) = 27(-7(((ln(z + 1))^(3/2) + 4)^2 + 1)^(1/2) 4y^3 + 21) - sin(e)

Answer 20

Interpret Unreadable code-golf interpreter

---

Introduction

Unreadable is a programming language designed to be – as the name states – unreadable (in most fonts, anyway). Instructions are ' followed by a run of "s. So while in a code block, '""'""'""" looks just fine, it looks like '""'""'""" outside of one - it is extremely difficult to tell what is going on.

The instructions are prefix, and are as so:

Instruction	Arity	Behavior
'"	Unary	Print; output the character with codepoint x, and return x.
'""	Unary	Increment; return x+1.
'"""	Nilary	Unit; return 1.
'""""	Binary	Both; evaluate and disregard x, and return the result of evaluating y.
'"""""	Binary	While; keep evaluating y until x is 0. Return the last result of evaluating y.
'""""""	Binary	Set; set the xth variable to y, and return y.
'"""""""	Unary	Get; return the value of the xth value. Undefined is 0.
'""""""""	Unary	Decrement; return x-1.
'"""""""""	Ternary	If-else; if x is 0, return z. Otherwise, return y.
'""""""""""	Nilary	Input; return the codepoint of the next character of input. EOF is -1.

For example, a cat program would be:

'"""""'""'""""""'"""'""""""""""'"'"""""""'"""
while(++ setvar(1 = input())) {print(getvar(1))}

Or, in its unreadable glory: '"""""'""'""""""'"""'""""""""""'"'"""""""'"""

Challenge

Given a valid Unreadable program and its input separated by any non-' or " character, interpret the program as Unreadable code.

Test cases (uses ! as the separation character, I/O is represented in CP-437)

Input -> Output
'"'"""!this input does nothing lol -> ☺
'"""""'""'""""""'"""'""""""""""'"'"""""""'"""!This is a cat so I can output whatever I want. blah blah blah... -> This is a cat so I can output whatever I want. blah blah blah...
'""""'""""'""""""'"""'""'""'""'""'""'""'""'""'""'"""'"""""'"""""""'"""'""""'""""""'""'"""'""'""'""'""'""'""'""'"""""""'""'"""'""""'""""""'""'""'"""'""'""'""'""'""'""'""'""'""'""'"""""""'""'""'"""'""""'""""""'""'""'""'"""'""'""'""'""'""'""'""'""'""'""'""'"""""""'""'""'""'"""'""""'""""""'""'""'""'""'"""'""'""'""'""'"""""""'""'""'""'""'"""'""""'""""""'""'""'""'""'""'"""'""'""'""'"""""""'""'""'""'""'""'"""'""""'""""""'""'""'""'""'""'""'"""'""'""'""'""'""'""'""'""'""'""'""'""'"""""""'""'""'""'""'""'""'"""'""""'""""""'""'""'""'""'""'""'""'"""'""'"""""""'""'""'""'""'""'""'""'"""'""""""'"""'""""""""'"""""""'"""'""""'"'""'""'"""""""'""'"""'""""'"'""'"""""""'""'""'"""'""""'"'""""""""'""""""""'"""""""'""'""'""'"""'""""'"'""""""""'""""""""'"""""""'""'""'""'"""'""""'"'""'"""""""'""'""'""'"""'""""'"'""'""'""'""'"""""""'""'""'""'""'"""'""""'"'""'""'"""""""'""'""'""'""'""'"""'""""'"'""""""""'"""""""'""'""'""'""'""'""'"""'""""'"'""'"""""""'""'""'""'"""'""""'"'""'""'""'""'"""""""'""'""'""'"""'""""'"'""""""""'""""""""'"""""""'""'""'""'"""'""""'"'"""""""'""'""'"""'""""'"'""'""'""'"""""""'""'""'""'""'""'"""'"'"""""""'""'""'""'""'""'""'""'""" -> Hello, world!
'""""""'"""'""'""""""""""'""""""'""'"""'""""""""""'"'"""""'""""""'"""'""""""""'"""""""'"""'""""""'""'"""'""'"""""""'""'"""!A! -> b

Rules

• Standard loopholes are forbidden.
• A single trailing newline is allowed in the output, and no other trailing whitespace.
• If possible, please link to an online interpreter (e.g. TIO) to run your program on.
• Please explain your answer. This is not necessary, but it makes it easier for others to understand.
• Languages newer than the question are allowed. This means you could create your own language where it would be trivial to do this, but don't expect any upvotes.
• This is code-golf, so shortest code in bytes wins!
• A +100 rep bounty will be given to the first Unreadable answer.

Answer 21

Can we measure time?

You have 2 hourglasses with sand lying at bottom in both of hourglass, one that is \$1\$ sec hourglass(call it \$A\$) and other is \$\sqrt2\$ sec hourglass (call it \$B\$)

(A hourglass is said to be n second hour glass if time taken by all of the sand of hourglass to fall from top to bottom is n second)

Now we are given 2 integers \$a\$ and \$b\$ such that $$T=a+b\sqrt2 > 0$$ assume:$$\ 1000000\geq a \geq -1000000$$

$$\ 1000000\geq b \geq -1000000$$

we need to respond that can we measure this time \$T\$ with our hourglasses? ("YES" or "NO")

Some clarifications and definitions:

• We say we can measure time \$t\$ if at that instance in at least one of hourglass sand have just stopped falling.

• We can make a hourglass upside down(any number of time) if and only if at least one of the hour glass has empty top.

• Assume time taken to invert a hourglass is 0 sec.(by invert means upside down,i.e the sand that was in bottom is now at top and the sand at top is now at bottom).

• If at least one of hourglass sand have just stopped falling we can report this instant as the amount of time measured.

• If sand on both the hour glass is at bottom and we decided to do no any operation, then it is assumed that we are reporting the time measured at this instance and the process stops.

Example 1:

\$a=0\$ and \$b=1\$

Our answer is true, because initially both the hourglass is given with sand at bottom and at the start we can invert B, so when the sand from B has fallen all to bottom at that instance a total of \$\sqrt2\$ time has passed and we can report it,hence we have measured \$\sqrt2\$ time.

Example 2:

\$ a=-1\$ and \$b=2\$

\$T = -1 +\sqrt2\$ Our answer is true, we can obtain it as follows: At time 0, turn both A and B upside down, At 1 sec A will be emptied to bottom, turn A upside down again (B remain falling as it was), now when B fall completely,turn A upside down, now when A empties the total duration is \$-1 +\sqrt2\$.

1(All the A falls, at this instance B is left with \$-1+\sqrt2\$ ) $$+$$ \$\sqrt2\$-1 (at this duration after the previous one B have fallen completely and A is left with \$1-(-1+\sqrt2)\$ at top, but we have inverted it so that means A is actually left with \$-1+\sqrt2\$ at top) $$+$$

\$-1+\sqrt2\$ (at this duration after the previous one A have fallen completely)

we can report this instant, the total time is:

\$(1)+(-1+\sqrt2)+(-1+\sqrt2)=-1 +2\sqrt2 \$

And for following input it is not possible to measure and you have to output "NO"

\$a=11\$ , \$b=-5\$

\$a=35\$ , \$b=-21\$

\$a=-4\$ , \$b=4\$

\$a=-8815\$ , \$b=6261\$

\$a=-1\$ , \$b=1\$

. . .

code-golfmathnumber-theory

The idea of this problem is not my original, it appeared in a coding competition some time back.

Answer 22

Convert permutations to integers and back again

permutations encode decode

Convert a permutation of 0,...,n-1 to a number in the range 0,...,n!-1, and convert back again.

Task

Write a program containing two functions (or two programs).

The first function should accept a permutation (i.e. an ordering) of the numbers 0,1,2,...,n-1 (where n is any positive integer) and output an integer in the range 0,1,...,n!-1 (where n! is n factorial). Distinct permutations of the same length n must produce distinct outputs, but there are no further restrictions.

The second function should implement the inverse of the first function (except that it also needs to know n). It should accept an integer k in the range 0,1,...,n!-1 AND a positive integer n, and should output the permutation of 0,1,2,...,n-1 that yields k when sent to the first function.

The time and space complexity of both functions MUST be at most polynomial in n, i.e. O(n**c) for some fixed c. In particular, solutions that involving computing all n! permutations are NOT acceptable. (Unofficial bonus points for O(n)).

Shortest solution (including both functions and any additional code) in each language wins.

Examples

Assuming the two functions are f and g:

Input	Output
f([0])	0
g(0,1)	[0]
f([0,1]), f([1,0])	0 and 1 in either order
g(0,2), g(1,2)	[0,1] and [1,0] in either order
f([3,4,1,0,2])	some integer in range 0,...,119
g(42,5)	some permutation of 0,1,2,3,4
f(g(42,5))	42
g(f([3,4,1,0,2]),5)	[3,4,1,0,2]
f([1,0,1])	not valid input (not a permutation)
f([1,3,4])	not valid input (not a permutation of 0,1,2)
g(42,4)	not valid input (42 >= 4!)

Notes

Permutations can be represented in any reasonable form.

You can assume that input(s) are valid (as described).

You can assume that n! fits in the standard integer type in your language, but your algorithm should theoretically work for any n.

Standard loopholes apply.

Answer 23

Boxes in boxes in boxes in boxes.....

ASCII boxes are fun, but the box drawing questions seem to be limited insofar as that they seem to take a specific set of boxes. Today, I hope to fix that. The challenge here is to write a program that takes a list of sides of boxes and characters to draw them with, and outputs the boxes.

To clarify some format issues:

Input

Input is flexible, and will look like 1) this

17

30 20 #$5

21 15 $%^

19 13 311

...

or 2) this

[17, [30, 20, "#$5], [21, 15, "$%^], [19, 13, "311"], ...]

You may support either or both of these types, but you must be consistent with this choice.

Input is given in this order:

The first number, a single number on one line, is the number of boxes to place.

Then, for as many times as said first number, you will receive 2 numbers and three characters - the two numbers represent length and width, in any order. The three characters represent, in this order:

1. The character to use for the corners.
2. The character to use for the edges.
3. The character to fill the inside of the boxes.

The boxes should not overlap, but you have the freedom to place the boxes wherever you wish. The allowed symbols are !$%^&*()_-+=#~/?\@s, where the s represents space and in order to aid those who want to split on whitespace.

Input will be space separated within boxes and newline separated between boxes.

Output

Output should be a set of boxes, conforming to the regulations and conditions above - for example,

%###%
#***# *((*
#***# ())(
#***# ())(
%###% *((*

for the input

2

5 5 %#*

4 4 *()

or

[2, [5, 5, "%#*"], [4, 4, "*()"]

Scoring

This is code-golf, so shortest solution in bytes wins. Share your favourite drawings with your answer.

Additional tags: stringascii-art

Meta

Any issues?

Should the scoring be popularity-contest?

Is the challenge specified enough?

Answer 24

Given matrix \$A\$ and \$A^n\$, work out any possible positive \$n\$.

Examples:

• \$\begin{pmatrix}1&2&3\\3&2&1\\1&0&1\end{pmatrix},\begin{pmatrix}36&32&44\\52&40&52\\12&8&12\end{pmatrix}\rightarrow 3\$
• \$\begin{pmatrix}0&1&0\\0&0&1\\0&0&0\end{pmatrix},\begin{pmatrix}0&0&0\\0&0&0\\0&0&0\end{pmatrix}\rightarrow \text{any integer }\ge 3\$
• \$\begin{pmatrix}0&1\\1&0\end{pmatrix},\begin{pmatrix}0&1\\1&0\end{pmatrix}\rightarrow \text{any odd positive integer }\$

Sandbox Notes

• Since this question likely fall into pure matmul as code-golf, will this be fastest-code?
• If so, what size and \$n\$ is reasonable?
• Should it multiply in a modulo-\$p\$ ring?
• If someone provide enough extra info, they have right to post this question(actually that's why I posted in sandbox)

Answer 25

I am not a dad!

Task

Given a non-empty string. Check if it starts with "I am"/"I'm" (case-insensitive) and if it is, output the dad joke. Otherwise, terminate
P.S. There must be nothing in the STDERR.

Examples:

"I am an idiot" -> "Hi an idiot, I am Dad"
"I am rewuytheruty" -> "Hi rewuytheruty, I am Dad"
"i Am case insensitive" -> "Hi case insensitive, I am Dad"
"I'm A" -> "Hi A, I am Dad"
"i'M B" -> "Hi B, I am Dad"
"Iam together" -> terminated
"Nothing here!" -> terminated

Rules

• This is code-golf, so the answer with shortest bytes wins.
• These loopholes are, obviously, forbidden.
• Standard code-golf rules apply.
• Please specify the language you are using and the amount of bytes.
• It would be great if you would put a link to a sandbox where your code can be ran in action, such as TIO.
• Explaining your code is very welcomed.

Answer 26

Write a shortest bijective program from String to Object.

You can specify two sets of chars \$C_1\$ and \$C_2\$, both of which consist of at least 4 different chars^[1], and define:

• String: string consisting of only chars in \$C_1\$ [C₁]*
• Name: non-empty string consisting of only chars in \$C_2\$ [C₂]+
• Object: a finite map from Name to Object, such that every way to go down finally go to empty Object(empty map)

Reasonable I/O allowed. Outputting in Object in languages like JavaScript, Array/String with proper encoding, folder, shuld be fine.

Notes

• [1] unary or binary is too easy.
• I meant to map to folder but folder charset is bad, then decided to give you choice.

Sandbox Notes

• What does proper encoding mean? Or do I just remove the allowance?

Answer 27

Largest number with no repeating substrings of length \$l\$

Inspired by this question, in turn inspired by this one.

When I read the above questions, I thought: "Cool". And then I thought "What if we go further?"

Therefore, in this challenge, you must find the largest number that has no repeating substrings of length n. This is code-golf: fewest bytes wins.

Meta Stuff

This seems insanely hard - is it well specified enough?

Any changes that seem reasonable to add?

Answer 28

Iterated ultimatum koth

Each round, players are paired. One player is the Proposer and the other is the Receiver.

The Proposer must choose a number x such that 0 < x < 100. The Receiver must then Accept or Reject this offer. If accepted, the Proposer gains x points and the Receiver gains 100 - x points. If rejected, neither player gains anything. This is repeated several times, then the Proposer and Receiver roles are reversed, then new pairings are made.

Repeat.

The idea is that the Proposer must try to maximise his own gain, while the Receiver can try to coerce the Proposer to give a larger share of the 100 points by rejecting unfair offers.

https://en.wikipedia.org/wiki/Ultimatum_game

Meta

• Too similar to Iterated Prisoner's Dilemma?
• Any other feedback?

Answer 29

Solve Encode a Lenguage with score 0. Shortest code wins. Quine rule applies. I'll unlikely post it.

Answer 30

Smallest number of panels to represent \$1\$ through \$n\$ in base \$b\$

Inspired by this question. (I have taken a lot of inspiration from Puzzling recently).

Because not all of you spend all your (non-code-golf) time looking at puzzles, let me explain the relevant details.

The challenge involved figuring out how to express the numbers 1 through 8 in only 8 panels in bases 2, 3 and 4. Today, I want to do the converse.

Your task is to, given a number \$n\$ and a base, \$b\$, find the fewest number of panels to represent 1 - n in base b. By that, I mean taking a single continuous slice of the set of panels, we can represent a number, and we can do that for 1 through n.

To clarify, each panel can take a single base-\$b\$ number, and the goal is to find a way to represent each number from 1 through n as a base b number. A continuous slice is a set of panels such that all the panels are consecutive and in the same order as in the original number - for example, 221001120 - in which every two-digit and one-digit number is represented in reading order, left-to-right, as well as 100. Note that 101 and 111 are disallowed because they are not consecutive, with 0s in between, 110, 122 and 2110 are disallowed because they read from left to right, and 121 and 212 are disallowed because they reorder the panels.

For a bigger example, let us take the base as 3 and the number as 18: a valid solution is 122121110221010011200, as every number between 1 and 18 can be represented in base 3

1: 122121110221010011200

2: 122121110221010011200

3: 122121110221010011200

4: 122121110221010011200

5: 122121110221010011200

6: 122121110221010011200

7: 122121110221010011200

8: 122121110221010011200

9: 122121110221010011200

10: 122121110221010011200

11: 122121110221010011200

12: 122121110221010011200

13: 122121110221010011200

14: 122121110221010011200

15: 122121110221010011200

16: 122121110221010011200

17: 122121110221010011200

18: 122121110221010011200

In order to verify your solution does work, provide an optimal answer by the number such that it can be checked.

Input looks like this: n b, and output like this: number solution.

Sample inputs and outputs to aid you (output is represented as o - yes I did work all of these out, and yes, I do believe it is the shortest to just find a place to append the number in):

\$b = 2\$:

n <= 8; o = n (11101000)
n = 9, 10; o = 11 (10011101000)
n = 11; o = 13 (1001011101000)
n = 12, 13, 14; o = 14 (11001011101000)
n = 15, 16; o = n (110010111010000)

\$b = 3\$:

n <= 9; o = n (221001120)
n = 10; o = 11 (22101001120)
n = 11; o = 13 (1022101001120)
n = 12; o = 14 (11022101001120)
n = 13, 14, 15; o = 15 (111022101001120)
n = 16; o = 17 (12111022101001120)
n = 17; o = 19 (12212111022101001120)
n = 18; o = 20 (122121110221010011200)

\$b = 4\$:

n <= 10; o = n (1101220213)
n = 11; o = 12 (231101220213)
n = 12, 13; o = 13 (231101220213)
n = 14, 15; o = n (33231101220213)
n = 16, 17; o = 18 (10033231101220213)
n = 18; o = 20 (1003323110122010213)
n = 19, 20; o = 22 (100103323110122010213)

(i'm not touching 5+ this took me an hour)