490
\$\begingroup\$

What is the Sandbox?

This "Sandbox" is a place where Code Golf users can get feedback on prospective challenges they wish to post to the main page. This is useful because writing a clear and fully specified challenge on the first try can be difficult. There is a much better chance of your challenge being well received if you post it in the Sandbox first.

To post to the Sandbox, scroll to the bottom of this page or click on the "Add Proposal" link below, 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. 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, replace the post here with a link to the challenge and delete it.

See the Sandbox FAQ for more information on how to use the Sandbox.

The Sandbox works best if you sort posts by "active".

Add Proposal

Search the Sandbox

Browse your pending proposals

Get the Sandbox Viewer to view the sandbox more easily

To add an inline tag to a proposal use shortcut link syntax with a prefix: [tag:king-of-the-hill]

| |
\$\endgroup\$

2966 Answers 2966

1
73 74
75
76 77
99
0
\$\begingroup\$

Moore-Penrose inverse

In linear algebra the pseudo-inverse of a matrix is a generalization of the inverse of a matrix which doesn't necessarily exist. One definition of a pseudo-inverse is called the Moore-Penrose inverse which shall be denoted by A⁺ in the following. Further let Aᵀ denote the transpose of the matrix A.

Definition

The Moore-Penrose inverse of the matrix A is defined for all matrices A in a way such that it satisfies the following four properties:

  • AA⁺A = A
  • A⁺AA⁺ = A⁺
  • (AA⁺)ᵀ = AA⁺
  • (A⁺A)ᵀ = A⁺A

Task

Your task in this challenge is, given a matrix real A (non-zero and non-empty) to compute its pseudo-inverse as defined above.

  • You're allowed to receive input as a single list, array, list of lists etc.
  • The input is a single non-zero, non-empty matrix with real entries
  • The input matrix is not necessarily square
  • Your program/function either returns the pseudo-inverse or prints it to STDOUT
  • You don't need to handle floating point inaccuracies
  • The behavior on invalid input (eg. []) is left undefined

Examples

Here are some possible examples (note the different (in)accuracies):

[4] -> [0.25]
[1 1; 1 0] -> [0 1; 1 -1]
[12 4 9; -9 1 3; -6 6 15] -> [0.0467129 -0.0342457 -0.0217785; 0.0115298 0.0022497 0.0160292; 0.0251844 0.0076240 0.0404324]
[0 1 0; 0 0 1; 0 0 0; 2 0 0] -> [0 0 0 0.5; 1 0 0 0; 0 1 0 0]
[1 1 2 3] -> [0.0667; 0.0667; 0.1333; 0.2]
[0; 0; 1] -> [0 0 1]
[1 0 0 0 0; 2 0 0 0 0] -> [0.2 0.4; 0 0; 0 0; 0 0; 0 0]

Sandbox

  • Should I ban built-ins (looking at Octave/Matlab, Mathematica etc.)?
  • Is the part with floating-point inaccuracies formal/objective enough?
  • Are more examples needed?

Tags: , , ,

| |
\$\endgroup\$
  • \$\begingroup\$ Having no challenge for computing a SVD, maybe I should reduce this to only computing the SVD of a matrix since that would be the heart of this challenge anyway. What do you think? \$\endgroup\$ – ბიმო Nov 22 '17 at 15:00
0
\$\begingroup\$

Examining the Student's Swing

The 2017 Level 1 Mathematics and Statistics NCEA examination paper has been making headlines in New Zealand for being 'impossible' and bringing students to tears.

One of the questions involves a children's playground swing, and finding where the holes in the swing seat should be placed. But lets generalise the problem in code in the fewest number of bytes, in case they have to solve for a different swing (in a different exam).

Task

Find how far apart the holes in the board need to be if the shape of the rope stays the same, given the following swing setup:

  • The rope hangs from a cross beam at a height h, and will have a parabolic shape, as presented in the exam (rather than a catenary shape), and will maintain this shape with the seat.
  • The rope is connected to the crossbeam at two points, that are separated by a distance d.
  • The lowest point (vertex) of the rope sits above the ground at a height of v.
  • We have an adequately sized wooden board for the seat, and we want this to be at a height s above the ground.

Exam questions often have a visual representation to help clarify the question, so I've also included one:

enter image description here

Rules

  • inputs must take positive real values
  • s will be greater than v
  • output must be correct to at least 2dp.
  • This is , therefore, the lowest byte count in each programming language wins
  • Standard rules apply, and no forbidden loopholes

Test Cases

(h,d,v,s) -> hole separation
(4, 6, 1, 1.2) -> 1.549
(10, 4, 2, 4) -> 2
(14.5, 12, 2.5, 5.5) -> 6
(4.25, 3.4, 0.5, 1.2) -> 1.468

Sandbox Questions

  • First time question, so any recommendations would be great
  • Any recommendations for how I can make this a well received question?
  • are there any rules I'm missing, or should add?
  • is this a duplicate?
  • What other tags should this question have?
| |
\$\endgroup\$
  • \$\begingroup\$ About the output must be correct to at least 2dp. part, I'm afraid that there will be some problems from that requirement. A better requirement is "the algorithm in the code must be able to theorically calculate to infinite precision, but numerical error from programming language type limit is acceptable". / Also, the "the rope is always in parabolic shape" is weird, is that correct? If so you should highlight it. (normally a unweighed rope has catenary shape, and a weighed rope has the shape of multiple straight line segment) / Otherwise the challenge looks good. \$\endgroup\$ – user202729 Nov 22 '17 at 7:48
  • \$\begingroup\$ Thanks for the suggestions; the 2dp was based on the exam question requirement of showing your working to 2dp, though I understand the precision issue. Maybe I just remove that rule? I didn't know about catenary shape, the exam question just used a parabola, so I'll highlight that fact. \$\endgroup\$ – Ayb4btu Nov 22 '17 at 8:39
  • \$\begingroup\$ So in other words, given (h,d,v,s) output d sqrt((s-v)/(h-v)). I don't think it's a duplicate, but I also think that the reason that it isn't is because everyone has previously (and correctly) concluded that calculating a square root without restrictions to prohibit builtin sqrt functions is too trivial to be worth posting. \$\endgroup\$ – Peter Taylor Nov 22 '17 at 15:00
  • \$\begingroup\$ @PeterTaylor Well, (you know) on this site it is generally discouraged to post a "puzzle", because once the first answer had been posted, the other answers can just use that - and your comment has already specified the method. / You meant sqrt should be prohibited? That will lead to the (well-known) do X without Y problem. \$\endgroup\$ – user202729 Nov 22 '17 at 15:15
  • \$\begingroup\$ @user202729, no, I did not mean that. I meant that "Calculate sqrt without a builtin sqrt" would be a duplicate (although maybe only of closed questions). See codegolf.stackexchange.com/q/73/194 and linked questions. \$\endgroup\$ – Peter Taylor Nov 22 '17 at 15:25
  • \$\begingroup\$ @PeterTaylor This exam question certainly simplified down to a trivial coding answer; I think I was more posting due to the story behind it. I'll have a think about if or how to make it a bit more challenging. Will just mean that it may not be as closely related to the exam question on which it is based. \$\endgroup\$ – Ayb4btu Nov 22 '17 at 20:29
0
\$\begingroup\$

View float numbers in graphical binary

IEEE 754 is a well known format for representing floating point numbers.

Your task is to give an input to the user where he/she enters a signed float number and represents clearly the number in a color separated by functional area binary 32 bit single representation, like:

  • You do not have to append the captions like they are in the figure.

  • You must follow the order Sign, Exponent, Fraction

  • You may choose whatever colors you want, as they are distinguishable from each other and from the binary text numbers.

  • The input (I suggest a text box) does not have to forbid invalid values, but if does not, the graphical binary view needs to indicate the invalidity. You can leave it empty or replace with some text like "ERROR" or "INVALID".

  • Every little change on the input needs to make the binary view to be immediately updated. Changing and have to confirm with an "OK" like button is not acceptable.

No winner, unless I see some very creative answer. I would like to see a golfed and an ungolfed version of the code.

| |
\$\endgroup\$
  • 1
    \$\begingroup\$ Needing the output to be dynamically updated based on the input changing (and not an OK or the like) is going to drastically limit the languages that can participate. \$\endgroup\$ – AdmBorkBork Nov 21 '17 at 18:58
  • 1
    \$\begingroup\$ Additionally to what @AdmBorkBork said, the requirement of dynamically updating the output & validating input is just distracting from the real challenge. I'd just leave behaviour on invalid input undefined. \$\endgroup\$ – ბიმო Nov 22 '17 at 15:08
0
\$\begingroup\$

Optimise Retina transliterations

For the question Translate Morse code based on tone duration I stupidly created the following transliteration:

T`T\EMNAI\OGKDWRUSJ2V\HBZ89#@`NIGDRS8ZCBP\LF\H12356789_`\w@#

The first thing wrong with it is that it 2, 8 and 9 transliterate to themselves, so they are superfluous. This saves 6 bytes:

T`T\EMNAI\OGKDWRUSJV\HBZ#@`NIGDRS8ZCBP\LF\H13567_`\w@#

The next thing to notice is that we have some runs of consecutive letters, but because they're not ordered we can't reduce them. Let's sort them:

T`ABD\EG\HIJKMN\ORSTUVWZ#@`R6BIZ5S1CGD8\L\HNF3P7`\w@#

We can now save another 3 bytes by using the run G-K, a byte by using the run M-O, and 3 bytes by using the run R-W:

T`ABD\EG-KM-OR-WZ#@`R6BIZ5S1CGD8\L\HNF3P7`\w@#

Total 13 bytes saved. Note that there are other optimisation opportunities but I think they might be too difficult be worth adding to the question; for instance, inserting a C (at a cost of 2 bytes) allows the creation of the run A-E for a 3-byte saving, which is still overall a byte saved; inserting all of the letters to achieve run A-Z would then be simplified to L.

Is the Retina command string too inflexible an input format? I suppose input could be in the form of an unordered mapping from printable ASCII to printable ASCII, but output would need to be the actual Retina syntax, including appropriate quoting, because the length of the result is important.

(Quoting: The characters -dEOHhLlwpoR`\ need to be quoted except that the letters don't need to be quoted as part of a range.)

Should this be a question or ?

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

A Knight's Walk

On a chessboard, a knight has two options for movement: it can move one square horizontally and two squares vertically, or two squares horizontally and one square vertically. In short, it can follow the path drawn by an upper-case "L". These can be oriented in any way, and as such, a knight has 8 potential moves from any given position.

There have been a number of challenges posted at one time or another regarding knights and their movement because they're so mathematically interesting (and the problems are easy to state) but we're going to go for a basic one that I haven't seen.

The Challenge

Given two 2d coordinates (x1, y1), (x2, y2) return the minimum number of moves required to travel from (x1, y1) to (x2, y2).

There are no other pieces on the board, and you may assume that the coordinate values given are valid (a set of two integers) though they may not be unique. You may also assume that each individual coordinate value will be between 0 and 255, and that the board is large enough that you needn't consider edges.

Input Format

As long as the coordinates are inputted in the order x1 y1 x2 y2 you can accept them as four separate values, two tuples, two lists, etc...

Examples

(0, 0) (1, 2) => 1
(0, 0) (1, 1) => 2
(125, 125) (126, 127) => 1
(-100, -100) (0, 100) => 100
| |
\$\endgroup\$
  • \$\begingroup\$ You might want to more explicitly state that negative numbers must be supported. Also, 'less than 128' applies only to inputs? or to anything? \$\endgroup\$ – Rɪᴋᴇʀ Nov 24 '17 at 0:24
  • \$\begingroup\$ Will do! And I'm not sure what you mean by that second part: I mean the input values will individually have absolute values of less than 128 a.k.a. (-127, -127) to (127, 127). This is totally a point I'm flexible on though. I just figured there may be languages that don't support very large numbers in any given memory location, and didn't want to give them additional hoops to jump through. Edit: Should I just make the valid range 0-255? \$\endgroup\$ – Willbeing Nov 24 '17 at 1:45
  • \$\begingroup\$ I'd recommend making it 0-255, yeah. I don't really think it's fair to have input be -127, +127, and then the boundaries of the chesboard be infinity. That's just kinda contradictory. \$\endgroup\$ – Rɪᴋᴇʀ Nov 24 '17 at 2:14
  • \$\begingroup\$ Do you think I should keep a bound like 255 at all? Would 2^16-1 or 2^32-1 be better? My whole premise with picking a number like this was that I want it to be easy to represent any number you'd run into, but impossible to use any kind of naive recursion to solve it \$\endgroup\$ – Willbeing Nov 24 '17 at 3:31
  • \$\begingroup\$ "impossible to use any kind of naive recursion to solve it" - Why? I don't understand your argument. / What is the winning criteria? \$\endgroup\$ – user202729 Nov 24 '17 at 13:29
  • \$\begingroup\$ @Willbeing I think 255 is fine, it doesn't matter too much. I've seen successful challenges that only require you to support up to 255, but that's it. \$\endgroup\$ – Rɪᴋᴇʀ Nov 24 '17 at 14:35
  • \$\begingroup\$ @user202729 Yeah, it sounds odd when its played back to me, hahaha. I only care if the program deterministically produces the correct step count. I still think limiting the input size is probs a good idea, just not for that reason anymore. \$\endgroup\$ – Willbeing Nov 24 '17 at 19:21
0
\$\begingroup\$

Clean duplicate website from my history

Introduction

I am looking for help to monitor my history. I parsed everything, but I am not yet happy with the final result. Could you help me? I want to remove following same website.

My history looks like this:

| url                                               | id |
|---------------------------------------------------|----|
| https://codegolf.stackexchange.com/q/147318/15214 | 4  |
| https://codegolf.stackexchange.com/q/148927/15214 | 4  |
| https://en.wikipedia.org/wiki/Code_golf           | 3  |
| http://lichess.org                                | 2  |
| https://en.wikipedia.org/wiki/Code_poetry         | 1  |

But I want it to be:

| url                                               | id |
|---------------------------------------------------|----|
| https://codegolf.stackexchange.com/q/148927/15214 | 4  |
| https://en.wikipedia.org/wiki/Code_golf           | 3  |
| http://lichess.org                                | 2  |
| https://en.wikipedia.org/wiki/Code_poetry         | 1  |
  • If I browse a site, then another one, then the first one. I keep all of them.
  • If I browse a site, then another part of the same site. I keep only the first one.
  • The list is ordered from young to old. (we keep the older)

This challenge is inspired by my day work, but it is not related in any ways with anything in it.

Challenge

  • Input is a list of identifier.
  • Output is a list of two elements (identifier's index, identifier).
  • No Empty input
  • No standard loophole
  • This is code-golf, so shortest answer in bytes wins.

Examples Input and Output

2 links on website 1

Input:

[ 1, 1 ]

Output:

[
    [1,1]
]

1 link on website 2, then 3 links on website 1

Input:

[ 1, 1, 1, 2]

Output:

[
    [2,1],
    [3,2]
]

1 link on website 1, then 1 link on website 2, then 2 link on website 1

Input:

[ 1, 1, 2, 1]

Output

[
    [1,1],
    [2,2],
    [3,1]
]

Question

  • Should I allow outputs as list of object, list of tuple or dictionary/map?
  • Should I ask for url parsing where identifier is the hostname?
| |
\$\endgroup\$
  • 1
    \$\begingroup\$ Question title and tag? \$\endgroup\$ – user202729 Nov 24 '17 at 14:11
  • 1
    \$\begingroup\$ Also I think the I/O specification (Input is a list of two elements. / Output is a list of two elements.") seems to contradict the test cases. \$\endgroup\$ – user202729 Nov 24 '17 at 14:33
  • \$\begingroup\$ @user202729 Update title, tag and I/O specs. Thank you. \$\endgroup\$ – aloisdg moving to codidact.com Nov 24 '17 at 14:53
  • \$\begingroup\$ You definitely should allow using tuples, maps and dictionaries for input and output. In fact, that's an understatement. You should read the meta post on I/O methods. URL parsing will make the challenge more interesting, IMO. \$\endgroup\$ – NieDzejkob Nov 24 '17 at 19:12
0
\$\begingroup\$

DNA Quine

Problem Description

Design a quine that outputs its own source code, but encoded into amino acids.
Read your source code in as binary. Each pair of bits now maps to a nucleotide like so:

00 -> A
01 -> C
10 -> G
11 -> T

For example, the ASCII character N has a binary representation of 01001110, so it would produce the nucleotide sequence CATG. A set of three nucleotides produces an amino acid. You can find the charts online, and I can't access imgur, so... yeah.

Anyways, your program must output its own source code as the three letter amino acid names. For example, if your code were 013201323300 in base 4, its nucleotide representation would be ACTGACTGTTAA and its amino acid representation would be ThrAspCysSTP.

Output

Your program must output its representation in amino acids.

Further Rules

All quines must also be valid proteins themselves. This means that:

  • The quine has a number of nucleotides divisible by three
  • The last three nucleotides are either TAG, TAA, or TGA, corresponding to a STP codon
  • No STP codons appear anywhere but the end of the quine.

Apart from that, the standard rules apply.

Scoring

This is code golf, so the shortest code wins.

Notes/Questions for Sandboxing

Ok, so I get that it's rather short. Is my point clear? Is the scoring section clear? How about loopholes? Should I point out that printing a single STP is not allowed? Would that even be possible?

| |
\$\endgroup\$
  • 1
    \$\begingroup\$ You might want to elaborate on "expand it into base 4". Does that mean get each byte's codepoint, concatenate into one big binary integer, and then convert to base 4? \$\endgroup\$ – FlipTack Nov 27 '17 at 20:00
  • \$\begingroup\$ What happens if the number of nucleotide is not a multiple of 3? | The base 4 conversion is indeed unclear. \$\endgroup\$ – user202729 Nov 28 '17 at 1:01
  • \$\begingroup\$ @user202729 if there's a spare nucleotide, it's not a valid program. \$\endgroup\$ – Jakob Lovern Nov 28 '17 at 1:27
  • \$\begingroup\$ So basically "program length must be a multiple of 3". / For example program 00 FF should be 00 00 00 00 11 11 11 11 = AAAATTTT or TTTTAAAA? \$\endgroup\$ – user202729 Nov 28 '17 at 1:52
  • \$\begingroup\$ Yeah, essentially. Except that some code golf languages have special character sets that aren't 8 bits, and some trickster out there might use that. \$\endgroup\$ – Jakob Lovern Nov 28 '17 at 2:10
  • \$\begingroup\$ @JakobLovern Unless there are some computers that can store fractional byte size, that won't be accepted. \$\endgroup\$ – user202729 Nov 28 '17 at 2:53
  • \$\begingroup\$ I have no idea how to convert CATG into amino acids. Challenges should be self-contained. \$\endgroup\$ – AdmBorkBork Nov 29 '17 at 14:46
  • \$\begingroup\$ I suspect most answers will be of the form "1. get string of source code by standard quine technique" and "2. convert string into dna form", so the first part doesn't add anything to the challenge. I'd suggest to change the task to write a program which translates a given string into your DNA format. \$\endgroup\$ – Laikoni Nov 29 '17 at 17:16
0
\$\begingroup\$

Create a Flip-Flop Program

Your challenge is simple: write a full program which alternates between two different outputs upon each run.

Your submission can choose which is printed the first time the program is run, but after that it should alternate between these exact outputs.

Rules/Details

  • You cannot assume the filename of your program.
  • The values must be distinct.
  • Creating files is allowed - you are allowed to assume a file such as a.txt does not already exist in the directory.
  • Reading and modifying the source is allowed.
  • This is , so the shortest solution (in bytes) wins! Standard golfing loopholes apply.

Sandbox

  • Should I allow assuming the program's filename at an additional bytecount (length of filename)?

| |
\$\endgroup\$
  • \$\begingroup\$ Is it neccessary that the first run always produces the same value? (That makes the problem considerably harder, because it requires detecting the first run.) I agree with the full program restriction here, btw; it avoids a lot of dubious rules-bending answers that change something in the execution state. \$\endgroup\$ – user62131 Jan 10 '17 at 16:58
  • \$\begingroup\$ If you want to be really crazy, you can do something like main(){int n = 1 Then change n in the compiled file return n;} \$\endgroup\$ – SIGSTACKFAULT Jan 12 '17 at 16:12
  • \$\begingroup\$ @FryAmTheEggman is this an explanation of the downvote or was that someone else? \$\endgroup\$ – FlipTack Nov 29 '17 at 8:02
  • \$\begingroup\$ @FryAmTheEggman see update. \$\endgroup\$ – FlipTack Nov 29 '17 at 8:14
  • \$\begingroup\$ Why the full program requirement? As far as I can tell, it will be very hard to do this with just functions. Why disallow something that could give interesting answers? Programs would likely just change their own source code, or read a value from a file and then change it (or append a new one). \$\endgroup\$ – Stewie Griffin Nov 29 '17 at 8:48
  • \$\begingroup\$ Closely related. \$\endgroup\$ – AdmBorkBork Nov 29 '17 at 14:39
  • \$\begingroup\$ @AdmBorkBork would you say that it's too similar? \$\endgroup\$ – FlipTack Nov 29 '17 at 16:36
  • \$\begingroup\$ Personally, I think they're distinct enough to not be a duplicate, they're just definitely related. \$\endgroup\$ – AdmBorkBork Nov 29 '17 at 16:41
  • \$\begingroup\$ I didn't downvote since to me this looked fairly good besides what felt like an arbitrary restriction that would just make gaming the challenge easier. Also, I remembered another related challenge, for reference. \$\endgroup\$ – FryAmTheEggman Nov 30 '17 at 0:25
  • \$\begingroup\$ @FryAmTheEggman that's why I recently helped add the stateful tag, all similar challenges involving storing data between runs and self-modifying code are gradually being added there \$\endgroup\$ – FlipTack Nov 30 '17 at 7:29
0
\$\begingroup\$

Thou shall permute!

Given a string of upper and/or lower case letters and/or numbers (or list of characters if you want), and a list of permutation cycles, compute every intermediate step of applying this permutation under the following rules:

  • The space to move letters around is one row above and one row below the input, with the same length available as the string length.
  • In the beginning, top and bottom row are empty, and the middle row contains the whole string
  • A character can only take the spot of another character, if that spot is empty
  • There can only be at most one character in the top row and one in the bottom row at any time
  • You can only move one character in one direction per state change. Directions are:
    1. Out of the middle top or down
    2. Left/Right (any number of steps at once)
    3. Into the middle

Cyclic Permutations

I'm assuming 0 based indexing. A list of cyclic permutations looks like this (I'm assuming list of tuples, but I don't mind if you want something else, as long as it conveys the same idea):

[(0,2,3),(1,4)]

This would mean that:

  • index 0 goes to index 2, index 2 goes to index 3, index 3 goes to index 0
  • index 1 goes to index 4, index 4 goes to index 1

Examples:

I'm using the -character to show available spots here, you may use a space or any character that can not be contained in the input string, such as #or $.

Given the string test and the cyclic permutations [(0,2)(1,3)], the steps would look as follows:

----
test  #Start state
----

----
-est  # Move index 0 out 
t---

--s-  
-e-t  # Move index 2 to the other side
t---

--s-
-e-t  # Move index 0 to where it needs to go
--t-

--s-
-ett  # Insert index 0 at index 2
----

s---
-ett  # Move index 2 to where it needs to go
----

----
sett  # Insert index 2 at index 0
----

----
s-tt  # Move index 1 out
-e--

---t
s-t-  # Move index 3 out
-e--

---t
s-t-  # Move index 1 to index 3
---e

---t
s-te  # Insert index 1 at index 3
----

-t--
s-te  # Move index 3 to index 1
----

----
stte # Insert index 3 at index 1. Done.
----

Here is the same example again, but this time using only one long permutation of all characters: [(0,2,1,3)] instead of 2 independent permutations:

----
test
----

----
-est
t---

--s-
-e-t
t---

--s-
-e-t
--t-

--s-
-ett
----

--s-
--tt
-e--

-s--
--tt
-e--

----
-stt
-e--

---t
-st-
-e--

---t
-st-
---e

---t
-ste
----

t---
-ste
----

----
tste
----

Rules

  • You will only receive valid cyclic permutations
  • Please indicate if you want 0 or 1 indexed permutations, either is fine
  • You will only receive valid strings up to length 10
  • Characters in the string are not guaranteed to be unique
  • it does not matter which order every permutation is processed as long as they're all processed (that means start and end states are the same, and the above rules are always fulfilled)
  • There will be at least one permutation in the list of permutations
  • All permutations in the list of permutations have at least length 2
  • The maximal length of one permutation is the length of the input string
  • There may be some indices that are not part of any permutation
  • No index is part of more than one permutation
  • You need to output the first step, the last step and all intermediate steps
  • You may have as many trailing newlines and spaces as you want
  • You may output a 2 dimensional array or anything equivalent instead of printing every step, or you can also return a list of all states in the end
  • You can also generate an animation if you like instead of printing sequentially
  • Lowest number of bytes wins
  • Standard loopholes are forbidden
  • You can write a full program or function

Test cases

I implemented a very un-golfed version in python3 here (redirects to repl.it). That code contains 2 functions. find_cycles takes a string and a permutation of that string and computes the cycles to go from one to the other. shuffle does the shuffling. It takes the start string and the cycles. You can use these functions to validate your program.

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

Find and execute a program from the internet

You have some task to do, but you are too lazy to do it yourself. Your also to lazy to make a program to do it. So you are going to make a program that finds a program to do the task you want.

Select a programming language Q (which must be Turing complete).

Your program will:

  1. Take an input task, as a string, and input, as a string.
  2. Search codegolf.stackexchange.com, using the input string as the query
  3. Select the first question in the search results with an answer which contains a valid Q program. (If there is no such question, the operation of your program may be undefined.) (You may assume that program is in a code block.)
  4. Select either the accepted answer if it contains a valid Q program, or the highest voted answer that contains a valid Q program.
  5. Execute the Q program that that answer contains, using the input from step 1.

Since you are lazy, you want your program to be the shortest program possible. So this is , shortest answer wins!

| |
\$\endgroup\$
  • 3
    \$\begingroup\$ What happens if the search result finds your answer? \$\endgroup\$ – Neil Dec 1 '17 at 9:55
  • \$\begingroup\$ @Neil Fixed it. \$\endgroup\$ – PyRulez Dec 1 '17 at 20:30
  • \$\begingroup\$ I don't know enough about the API to say, but can the order of results be changed by changing the search query to only allow questions? It seems like the searching may result in people trying to work around doing some API work, and it will be a pain to check. This isn't really a problem, just something I think you should know before posting. \$\endgroup\$ – FryAmTheEggman Dec 1 '17 at 20:37
  • \$\begingroup\$ @FryAmTheEggman I'm not sure. Think it would be better if I allow people to change the search query to only questions? \$\endgroup\$ – PyRulez Dec 1 '17 at 20:39
  • \$\begingroup\$ I think that would make it easier, but it kind of results in two separate golfing tasks: minimising the search query and minimising the code to parse/execute answers. I'm not sure of a good way to resolve that (or if it is that bad) but it does give me the feeling that it may be better split up in some way. \$\endgroup\$ – FryAmTheEggman Dec 1 '17 at 20:43
  • \$\begingroup\$ @FryAmTheEggman I could allow them to take a search query string template as input (or just say that it doesn't count towards their score). That way, there is no need to golf it. \$\endgroup\$ – PyRulez Dec 1 '17 at 20:45
  • 1
    \$\begingroup\$ What if the result takes no/more than one input? If Q is chosen well enough, you get away with a nop.. so this becomes a quest of finding languages unused on PPCG. What happens if these then get added? \$\endgroup\$ – ბიმო Dec 3 '17 at 3:15
  • \$\begingroup\$ @BruceForte It will be fed into the program via standard input. I said that Q must be Turing complete, which means it must take input. \$\endgroup\$ – PyRulez Dec 3 '17 at 4:51
0
\$\begingroup\$

Information Masking

Email Address Masking:

Only show the first and last characters of the username components of an email address, along with email domain name. Include 5 stars in the middle of the username to mask the length. The username part of the email address may use any of the ASCII characters listed below.

Rules

  1. Uppercase and lowercase English letters (a-z, A-Z)
  2. Digits 0 to 9
  3. Characters ! # $ % & ' * + - / = ? ^ _ { | } ~
  4. Character . (dit, period, full stop) provided that it is not the first or last character, and provided also that it does not appear two or more times consecutively.
  5. It is provided that email should end with @domainName.com, where the domain name has only alphabetic characters.
  6. It is provided that email address username part have at least 2 characters not starting and ending with a special character.

Example

JackAndJill@gmail.com --> j*****l@gmail.com

Phone number masking:

Rules

Mask all the digits in a phone number except the last 4 digits. Each number should be replaced by star(*). Input phone numbers can be with or without the country code. Input Phone numbers can only have +, (, ), - in them along with numbers and spaces. Make sure + is not masked in the output and make sure the number of stars is equal to the number of digits while masking.Phone numbers will always have 10 digits without country code and with the country code, they could be up to 13 digits.

Examples

Example1: +1 (333) 444-5678  --> +*-***-***-5678  
Example2: +91 (333) 444-5678 ->  +**-***-***-5678  
Example3: 333 444 5678 --> ***-***-5678  
Example4: (333) 444-5678 ---> ***-***-5678

Program input will start with E: for email and P: for phone numbers, ignore spaces if they are found in the input.

Complete Program Example

Input:

E: jackAndJill@gmail.com  
P: +13334445678

Output:

E: j*****l@gmail.com  
P: +*-***-***-5678
| |
\$\endgroup\$
  • \$\begingroup\$ How does hackAndJill start with a j? \$\endgroup\$ – NieDzejkob Nov 30 '17 at 21:06
  • \$\begingroup\$ Just a typo. Corrected now. \$\endgroup\$ – Siraj Alam Dec 1 '17 at 3:37
  • \$\begingroup\$ The examples show phone numbers of various different formattings what is it? Why are - in the output where in the input were only numbers how does that work? Is input always valid, can input be only a phone number etc. What about email addresses such as user@remote or u@remote.net? \$\endgroup\$ – ბიმო Dec 3 '17 at 3:25
  • \$\begingroup\$ The input number can be in any format as the given in the example. And it is should be output in the form that last phone numbers are shown and then a -, then every 3 numbers are masked as *** and a - after it until the numbers do not end. \$\endgroup\$ – Siraj Alam Dec 3 '17 at 6:41
  • \$\begingroup\$ Email address rules are updated. \$\endgroup\$ – Siraj Alam Dec 3 '17 at 6:45
  • \$\begingroup\$ What is the winning criterion? Code-golf? \$\endgroup\$ – Laikoni Dec 3 '17 at 20:24
  • \$\begingroup\$ Yes, code-golf. \$\endgroup\$ – Siraj Alam Dec 3 '17 at 20:25
0
\$\begingroup\$

Given an Integer array:

  1. Start from the first number (n)
  2. Go forward (n) positions depending on the current position
  3. Delete the current position, the rest of the array fill in to the current position.
  4. Goto step 2 until there are one number remaining
  5. Print that number

The array loops around (the next number after the last number in the array is the first number).

A zero removes itself.

Negative numbers are not allowed as input.

Test Cases

[1] => 1
[1,2] => 1
[1,2,3] => 3
[1,2,2] => 1
[1,2,3,4] => 1
[6,2,3,4] => 4
[1,2,3,4,5] => 5
[0,1] => 1
[0,0,2,0,0] => 0

This is , the shortest answer in bytes wins!


Step-by-step example

[1,4,2,3,5]
 ^          start from the first position
   ^        jump 1 position (value of the position)
[1,  2,3,5] remove number in that position
     ^      take next position of the removed number
         ^  jump 2 positions
[1,  2,3  ] remove number in that position
 ^          take next position (looping on the end of the array)
     ^      jump 1 position
[1,    3,5] remove number in that position
       ^    take next position (looping)
       ^    jump 3 positions (looping on the end of the array)
[1,      5] remove number in that position
         ^  take next position
 ^          jump 5 positions (looping)
[        5] remove number in that position
print 5

Example #2

[4,3,2,1,6,3]
 ^            start from the first position
         ^    jump 4 positions
[4,3,2,1,  3] remove number in that position    
           ^  take next position
     ^        jump 3 positions
[4,3,  1,  3] remove number in that position    
       ^      take next position
           ^  jump 1 positions
[4,3,  1    ] remove number in that position    
 ^            take next position
   ^          jump 4 positions
[4,    1    ] remove number in that position    
       ^      take next position
 ^            jump 1 position
[      1    ] remove number in that position
print 1

Note: This is my first challenge so any input is welcome.

| |
\$\endgroup\$
  • \$\begingroup\$ After the step 2 where is the "pointer"? \$\endgroup\$ – user202729 Dec 10 '17 at 14:40
  • \$\begingroup\$ The third step is worded a bit oddly, but I think I've understood it correctly from the examples. Do you mean that the elements after the deleted element are shifted to fill in the gap? It may be worth having one example written out step by step to make it easier for people to grasp what is happening. \$\endgroup\$ – FryAmTheEggman Dec 10 '17 at 15:13
  • \$\begingroup\$ @FryAmTheEggman I have edited the question to include 2 step-by-step examples. Can you help me word the third step more clearly? Perhaps: 2- jump forward n positions where n is the value of the current position. 3- delete the position you just arrived at. 4- the (new) current position is the next position. repeat step 2. \$\endgroup\$ – workoverflow Dec 10 '17 at 21:18
  • \$\begingroup\$ Problem title ? \$\endgroup\$ – user202729 Dec 11 '17 at 5:52
  • 1
    \$\begingroup\$ That is better, but maybe roll it into one? "Delete the current position, making what was the next position the current position" \$\endgroup\$ – FryAmTheEggman Dec 11 '17 at 5:57
  • \$\begingroup\$ @user202729 Haven't decided yet, Maybe "Football Jersey Josephus" or a variation of Duck, Duck, Goose. \$\endgroup\$ – workoverflow Dec 11 '17 at 7:38
0
\$\begingroup\$

Golf a number

Create a program or function, which when given an input integer, outputs a mathematical expression evaluating to the same value. Expressions which require fewer bytes to represent than the integer itself will achieve better scores!

Explanation

It is often useful when golfing to compress constant integer expressions by expressing them in the form of an equivalent mathematical expression. 387420489 for example is much more efficiently expressed as 9^9. Similarly 4194303 as 2^22-1

The challenge is, for each integer in the range 1 to 1E6, to golf the number into as short an expression as you can (although any expression which evaluates correctly is acceptable output, see Rules below). The shorter the expression, the better your score; but short programs will also score well so the two need to be balanced!

Rules:

Input integer as argument or from STDIN

Output as string or equivalent to STDOUT or as function output. Your string can only contain ascii characters [0,1,2,3,4,5,6,7,8,9], as well as those operators defined below, repetitions allowed.

You may use the following mathematical operators any number of times in your string:

() parentheses
^ exponentiation
* multiplication
/ division
\ integer(floor) division - see Test Evaluator
+ addition
- subtraction

NB: division, integer division and multiplication are all evaluated with equal priority, so 3/2\2 = 0 whereas 3\2/2 = 0.5

You may output the input value (if it can't be golfed for example), you do not have to output the perfectly golfed string:

 In: 10000

Out: 10000
     10^4
     2^13+1808

However the output must evaluate exactly to the input (assuming perfect precision of floats)

Scoring

Answers are scored on their compression ratio (how much they golf the input down on average), as well as program size

Program Size: byte count of program (as with normal code golf)

Compression Ratio: golfed Length (white-space ignored) / input Length

Individual Score = (Compression Ratio * 100 - 70)/6 + Log(Program Size, base 10)

Final Score = Mean score for first 10^6 integers

Lowest final score for each language wins!

Tags:


Sandbox:

related

related

The main sticking point is scoring how best can you combine 2 metrics into a single score?

The logic so far is that compression ratios will lie in the range 100 - 70 % where 100 is returning the input. Program lengths should be between 2 extremes; returning the input (1 byte) and looking up the input in a hardcoded list (~19,000,000 bytes). This gives the following distribution:

Score table

Actual program length I guestimate will be anywhere in the range 1 to 10000 bytes, hence the log to make the range more manageable. Quick reference; I could probably implement all power golfing (expressing n as a^b) in ~100-200 bytes in VBA. So 10% of that for golfing languages, and who knows what builtins Mathematica has ;).

But implementing more effective algorithms may require a more verbose language, so I think 1 - 10000 seems like a good range to handle in scoring

Open to alternative scoring though, and any required clarifications. Also suggestions what is a good range to test over?

I've suggested 1 to 1E6; The first 1000 integers I don't think are golfable, after that only a few are. So perhaps a greater range of test cases, or ones starting at a larger initial value? What's the biggest range I can feasibly test within say, 10 mins running time max? What's typical algorithm execution times can be expected per digit? I don't want golfers to have to spend too long generating their average score...

Test String Evaluation

| |
\$\endgroup\$
  • 1
    \$\begingroup\$ requires fewer bytes to represent than the integer itself. -- but you had said The first 1000 integers I don't think are golfable, so it doesn't work. \$\endgroup\$ – user202729 Dec 11 '17 at 5:58
  • \$\begingroup\$ In your test, 2^13+1808 is longer than 10000. It contradicts your problem statement. Also you don't allow ^ to be used. / Evaluate left to right? \$\endgroup\$ – user202729 Dec 11 '17 at 5:59
  • 1
    \$\begingroup\$ returning the input is 0 byte in most languages, so the score would be log(0) = -Infinity. \$\endgroup\$ – user202729 Dec 11 '17 at 6:01
  • \$\begingroup\$ Related. \$\endgroup\$ – user202729 Dec 11 '17 at 6:17
  • \$\begingroup\$ @user202729 Your 1st point; I did include a sentence you do not have to output the perfectly golfed string in the rules section, but I'll fix the problem statement to match that. Good catch with ^, I'll add that - but a longer expression is supposed to be acceptable. log(0) - well let's hope that's an incentive not to post trivial answers! But seriously, do you think it's worth adding a log(program length +1)? I don't think it is because it adds an additional layer of complexity to the scoring system - and people shouldn't really be entering trivial solutions anyway (I hope) \$\endgroup\$ – Greedo Dec 11 '17 at 10:49
  • \$\begingroup\$ If they do post 0-byte solution and win, it's the fault of your scoring system. For reference, look at the score formula of this challenge. --- You may want to add "you must calculate your score" to the question, like in this challenge. \$\endgroup\$ – user202729 Dec 11 '17 at 12:36
  • \$\begingroup\$ This isn't code-golf - it's code-challenge. \$\endgroup\$ – user45941 Dec 11 '17 at 16:30
0
\$\begingroup\$

All possible distributions of different items of a set to an arbitrary number of groups

See Descriptive Real World Example, Rules / Edge Cases or Sample Data for an idea about this or help me by adding a nice sentence explaining it while this is in sandbox.

Descriptive Real World Example:

Ordering a set of x items from a shop what are the possibilities to distribute them among 1 to x orders?

Rules / Edge Cases

  • Identical items are not being distinguished (AB, B == AB, B, compare examples #4, #5 and #6)
  • Order is not important
    • Order of items in order/group: AB == BA
    • Order of orders/groups in distributions: A, B == B, A
    • Order of possible distributions (i. e. lines among output)

Format

I don't really mind the exact format but as it probably makes sense (right?) to tie oneself down to one format I'll suggest the following:

  • Input: Set of items without delimiters. Supported chars: [A-Za-z0-9]
  • Output:
    • Hierarchy: Distributions (Orders (Items))
    • Delimiters:
      • Among distributions in overall output: EOL
      • Among orders/groups in distribution: Comma, Space
      • Among items in orders/groups: None

Sample Data

╔═════════╤═══════╤═════════╤════════════╗
║ Example │ Input │ Output  │   Output   ║
║   Nr    │       │ line nr │   lines    ║
╠═════════╪═══════╪═════════╪════════════╣
║   #1    │ A     │    1    │     A      ║
╠═════════╪═══════╪═════════╪════════════╣
║         │       │    1    │    A, A    ║
║   #2    │ AA    ├─────────┼────────────╢
║         │       │    2    │     AA     ║
╠═════════╪═══════╪═════════╪════════════╣
║         │       │    1    │    A, B    ║
║   #3    │ AB    ├─────────┼────────────╢
║         │       │    2    │     AB     ║
╠═════════╪═══════╪═════════╪════════════╣
║         │       │    1    │  A, A, A   ║
║         │       ├─────────┼────────────╢
║   #4    │ AAA   │    2    │   AA, A    ║
║         │       ├─────────┼────────────╢
║         │       │    3    │    AAA     ║
╠═════════╪═══════╪═════════╪════════════╣
║         │       │    1    │  A, A, B   ║
║         │       ├─────────┼────────────╢
║         │       │    2    │   AA, B    ║
║   #5    │ AAB   ├─────────┼────────────╢
║         │       │    3    │   AB, A    ║
║         │       ├─────────┼────────────╢
║         │       │    4    │    AAB     ║
╠═════════╪═══════╪═════════╪════════════╣
║         │       │    1    │  A, B, C   ║
║         │       ├─────────┼────────────╢
║         │       │    2    │   AB, C    ║
║         │       ├─────────┼────────────╢
║   #6    │ ABC   │    3    │   AC, B    ║
║         │       ├─────────┼────────────╢
║         │       │    4    │   BC, A    ║
║         │       ├─────────┼────────────╢
║         │       │    5    │    ABC     ║
╠═════════╪═══════╪═════════╪════════════╣
║         │       │    1    │ A, B, C, D ║
║         │       ├─────────┼────────────╢
║         │       │    2    │   AB, CD   ║
║         │       ├─────────┼────────────╢
║         │       │    3    │   AC, BD   ║
║         │       ├─────────┼────────────╢
║         │       │    4    │   BC, AD   ║
║         │       ├─────────┼────────────╢
║         │       │    5    │  A, BC, D  ║
║         │       ├─────────┼────────────╢
║         │       │    6    │  B, AC, D  ║
║         │       ├─────────┼────────────╢
║         │       │    7    │  C, AB, D  ║
║         │       ├─────────┼────────────╢
║   #7    │ ABCD  │    8    │  A, CD, B  ║
║         │       ├─────────┼────────────╢
║         │       │    9    │  A, BD, C  ║
║         │       ├─────────┼────────────╢
║         │       │   10    │  B, AD, C  ║
║         │       ├─────────┼────────────╢
║         │       │   11    │   ABC, D   ║
║         │       ├─────────┼────────────╢
║         │       │   12    │   BCD, A   ║
║         │       ├─────────┼────────────╢
║         │       │   13    │   CDA, B   ║
║         │       ├─────────┼────────────╢
║         │       │   14    │   DAB, C   ║
║         │       ├─────────┼────────────╢
║         │       │   15    │    ABCD    ║
╚═════════╧═══════╧═════════╧════════════╝
| |
\$\endgroup\$
  • 1
    \$\begingroup\$ What is the winning criterion of this challenge? Code-golf? Also the current explanation seems more complicated as it needs to be. Only after seeing the examples it became clear that you are asking for set partitions \$\endgroup\$ – Laikoni Dec 20 '17 at 15:09
  • \$\begingroup\$ Possible duplicate of codegolf.stackexchange.com/q/8691/56433 \$\endgroup\$ – Laikoni Dec 20 '17 at 15:12
0
\$\begingroup\$

Show me your core

On many 8-bit machines, it is relatively easy to output the entire core syntax of the built-in language, as everything required is in ROM and most 8-bit machines allow you to PEEK at each location therein, or otherwise easily access the ROM contents.

Here's the complete syntax for a Sinclair ZX81 or Timex TS1000/1500 machine as an example:

 1 PRINT CHR$ 64;CHR$ 65;CHR$ 66;CHR$ 193;CHR$ 193;
 2 FOR I=196 TO 255
 3 PRINT CHR$ I;
 4 NEXT I

Is it as easy to output the core or standard syntax to a screen, console, or window in modern-days languages? How best would I word such a question? And would this make a good challenge?

| |
\$\endgroup\$
  • 1
    \$\begingroup\$ What is the "core"? ...... \$\endgroup\$ – user202729 Dec 20 '17 at 15:03
  • \$\begingroup\$ Core syntax, i.e., non-extended PHP, such as stdClass is in the PHP core. Either the question is too ambiguous, or I don't know modern-days programming speak well enough to ask it. \$\endgroup\$ – Shaun Bebbers Dec 20 '17 at 15:08
  • \$\begingroup\$ More precisely, PDOException("blah", 0x00); would not be core in PHP even though it extends the standard Exception because the PDO extension needs to be switched on in your php.ini file; throw and new obviously would be as far as I'm able to work out \$\endgroup\$ – Shaun Bebbers Dec 20 '17 at 15:12
  • 1
    \$\begingroup\$ I don't know PHP so I don't understand that explanation. \$\endgroup\$ – user202729 Dec 20 '17 at 15:12
  • \$\begingroup\$ I only really understand PHP and some 8-bit hl languages and some assembly. Let's try this... if you don't <include xxx.h> in C (where xxx is the header or whatever), what are you left with? Is that even possible. \$\endgroup\$ – Shaun Bebbers Dec 20 '17 at 15:17
  • 1
    \$\begingroup\$ Actually GCC let the program pass with a lot of warnings. \$\endgroup\$ – user202729 Dec 22 '17 at 14:54
  • 1
    \$\begingroup\$ Some similar and related challenges showing that this type of challenge has a lot of difficulty in getting it exactly correct. \$\endgroup\$ – AdmBorkBork Dec 22 '17 at 15:10
  • \$\begingroup\$ Yes there is a lot of difficulty on modern-days tech stacks and such; on 8-bit machines, it's much easier as you only need to find the bit of ROM that holds the syntax and you're half-way there. \$\endgroup\$ – Shaun Bebbers Jan 2 '18 at 9:26
0
\$\begingroup\$

Sight Matrix


I haven't seen this done anywhere yet after a couple of searches, so I might as well post this anyways. If you see this done somewhere else, please tell me and I will delete this post.

The Story

You are a two meter tall sniper fighting in a war-torn area. Your teams have just beaten back the enemy, but the guerillas have an annoying habit of hiding out of sight and waiting patiently to take your unit by surprise, often inflicting heavy casualties. You have been tasked with dealing with these guerillas as a sentry.

The Task

Summary

Write a program that, when given a n x n 2D matrix of heights (in meters), outputs a n x n 2D binary matrix with ones being areas that you can see and zeroes being areas that you cannot see.

Input Format

The input will be a two-dimensional array of heights and two numbers signifying where you are standing.

Output Format

The output will be a two-dimensional array of ones and zeroes: ones where you can see and zeroes where you can't see.

Sample input/output

Input:

[[120,87,89,93,121], [120,91,83,91,114], [118,121,90,93,97], [124,129,115,120,101], [117,140,138,124,99]] 0 0

Output:

[[1,1,1,1,1], [1,1,1,1,1], [1,1,1,1,1], [0,0,1,1,1], [0,0,0,0,1]]

Hint:

Last time I checked, people's eyes were on their head. Put that into account when you are writing your code.


This is . Shortest answer in bytes wins. Standard loopholes apply.

Note: this is my first foray into code-golf stackexchange. Please tell me how to improve this or things that I need to add to this answer.

| |
\$\endgroup\$
  • 2
    \$\begingroup\$ There have been various questions on line of sight, but right now I think this question would be closed as "Unclear what you're asking" before there was consensus on which was the closest dupe. What are the rules for visibility? You've given my height, but I'm not sure whether it's relevant. You haven't said whether the guerrillas (note: double r) have a height, nor how the terrain is modelled, nor what point in the square I need to see for the square to count as visible. \$\endgroup\$ – Peter Taylor Dec 22 '17 at 13:47
  • \$\begingroup\$ May the input be 1-indexed? \$\endgroup\$ – user202729 Dec 22 '17 at 14:34
0
\$\begingroup\$

Output One More than Int Max

Your job is to create a program or function that will output a whole number (with no trailing decimal point) that is 1 greater than the max number an integer can hold for the language; more or less this:

MAX_INT + 1

You are not allowed to use Strings in your solution. Any other type may be used.

Shortest answer in bytes wins.

Note: I know this might be impossible in some languages. I have verified that it is possible in at least one (un-disclosed) language.


Notes on this puzzle

I posted this puzzle recently here and it promptly got closed and deleted (oops). Thankfully, @WheatWizard was kind enough to explain what some of the confusion was. Here where his comments:

I've voted to close this question as unclear. There are a couple of things I find especially unclear, 1) I'm not sure what "the max number an integer can hold for the language" means, it definitely needs a more concrete definition. It seems to presuppose some bounded "integer" type in the language. All the existing answers seem to suppose that long (or equivalent) is not this integer type but that is not at all clear from the question.

2) The requirement "You are not allowed to use strings in your solution" is neither clear nor enforceable. Without a rigorous definition of string there is no way to determine what is a string or not. For example Prolog has a type called "String" but all real string manipulation is actually done on lists of char codes. Are those strings? Prolog also has atoms which behave a lot like strings in many ways, (and act like integers in others) are they strings?

The main thing I would want to see before retracting my close vote/voting to reopen is clear definitions of the terms in question. To be clear that is a very tall order. These terms are not going to be easy to define, let alone define well. I would recommend temporarily moving this question to the sandbox so that you can workshop it a bit.

@Xcali said the following:

To follow on @WheatWizard's comment, what about languages where there's really no type to a variable. For example, in Perl, any single value may be treated as a string or a number at any time

And @Adám:

@CalebKleveter I think you can fix your challenge by removing the prohibition on strings and requiring documentation and/or additional supporting code showing that the produced number cannot be held as any type of integer. Do you want me to edit your post accordingly?

Are there any suggestions on how we could define the things pointed out in these comments? Are there any other issues that should be resolved?

| |
\$\endgroup\$
  • \$\begingroup\$ I'm not sure if it's possible to define such things such that it can applies to all languages. You may want to limit the challenge to specific languages, but that will disallow many languages to compete, and some person will get annoyed when their languages can't be used, they may downvote the question. / Original challenge link. \$\endgroup\$ – user202729 Dec 22 '17 at 14:07
0
\$\begingroup\$

Als pr Yrck, I knw hm Hrtio

Here is a link to a text file containing the script for Shakespeare's Hamlet.[to do: provide such a text file, or think of another freely available text input that leads to a wittier title.]

Your task is to write a program that will compress this text, and another that will decompress it to return exactly the original file. Your score is given by C + D + 0.5*F, where C is the size of your compression program, D is the size of your decompression program, and F is the size of the file that your compression program generates, all measured in bytes. The smallest score wins.

Further particulars

Your compression program should take hamlet.txt as input and produce a single file as output, which is to be given as input to your decompression program. You should make sure that the resulting output from your decompression program is identical to the original hamlet.txt file, e.g.

> myCompressor hamlet.txt > compressed
> myDecompressor compressed > output.txt
> diff hamlet.txt output.txt
[no output from diff command means they are identical]

Your programs' only purpose is to compress and decompress the hamlet.txt file - their behaviour on any other input is not part of the challenge. It's fine, for example, if the decompressor always outputs the text of Hamlet regardless of the original input, or if the compressor crashes on any input besides hamlet.txt.

Input and output can be by file I/O or STDIN/STDOUT or any other reasonable method, but the compressor and decompressor should be full programs. They need not be written in the same language.

Your compressor and decompressor must each be completely self-contained. Each must consist of a single file, and that file must be the source code for a programming language as defined here. With the exception of importing libraries, your compressor and decompressor must not open any other files besides their input.

The compressed file may be a text file or a binary file - the only thing that matters is its size in bytes. No information may be transmitted from the compressor to the decompressor by any means other than the content of this file.

You may not use any libraries or built-ins that implement data compression algorithms, such as gzip or bz2, or their corresponding decompression algorithms. This restriction only applies to "off the shelf" implementations - you can use any algorithm you like if you implement it yourself. For details on what counts as a data compression algorithm, see note 1.

If for some reason your language or libraries include a feature that outputs some or all of the text of Hamlet, you may not use that feature.

Although it's not part of the challenge, you are encouraged to explain/demonstrate what happens when your compressor is given some other input besides hamlet.txt, especially if it does something interesting such as produce a garbled Shakespearean version of the input text.

Note 1: For the purpose of this challenge, a data compression algorithm is anything listed in Wikipedia's Category:Lossless Compression Algorithms or Category:Lossy Compression Algorithms, or any of their subcategories. Note that these lists can change over time, and if Wikipedia's editors will allow a new item to be added then that will count as a compression algorithm, even if that happens after an answer using it is posted. This is to prevent the use of obscure algorithms that are not yet listed on Wikipedia. Editing Wikipedia to get around the restriction on off-the-shelf compression is not allowed.

This rule is intended to prevent the use of existing algorithms while allowing all other language features and built-ins. It may be the case that some items on the Wikipedia list are overly broad and end up banning common language features. If this is the case I will add exceptions on a case-by-case basis. This will only be used to permit things that would otherwise be banned, so it won't invalidate existing answers.


Sandbox note: the really tricky thing here is how to prevent trivial solutions that just wrap an existing compression algorithm, without also banning common language features. The above Wikipedia-based definition of a compression algorithm is a bit experimental and I'd welcome feedback on it. My intention is to prevent trivial solutions that just wrap an existing implementation of a compression algorithm, while allowing pretty much anything else.

Another possible approach is simply to allow anything and hope that answers specialised to the input can achieve better scores. That's effectively what I did in Paint Starry Night, but in the end I wish I hadn't, because it turned out that (so far at least) even really clever solutions based on neural nets and genetic algorithms can't come close to the off-the-shelf BPG algorithm. That's the sort of situation I want to avoid for this challenge.

| |
\$\endgroup\$
  • \$\begingroup\$ Would compressor, decompressor be acceptable? (only for illustration purposes) \$\endgroup\$ – user202729 Dec 30 '17 at 9:06
  • \$\begingroup\$ @user202729 I don't speak Jelly, but assuming it's not using any built-in compression, that would be fine. (It even says so already in the rules: "It's fine, for example, if the decompressor always outputs the text of Hamlet regardless of the original input".) The thing is that a solution of that form doesn't take any advantage of the discounted scoring for the compressed file, so it would very likely not be optimal. So while it's allowed, it would probably not win. \$\endgroup\$ – Nathaniel Dec 30 '17 at 9:46
  • \$\begingroup\$ Correct, if the text is sufficiently long. The “...» is Jelly string encoding codec using base decompression and some dictionary lookup. \$\endgroup\$ – user202729 Dec 30 '17 at 9:55
  • \$\begingroup\$ @user202729 then it would be fine. (I'm fairly certain the script for Hamlet is long enough - if it isn't, that would be an interesting surprise.) \$\endgroup\$ – Nathaniel Dec 30 '17 at 10:58
  • \$\begingroup\$ @user202729 Though actually, I guess by the letter of what I wrote, it wouldn't be fine, because Jelly's dictionary lookup is presumably explicitly intended as a way to compress text. That's not what I intended the rule to mean. This is pretty tricky - I want to disallow trivial things like just wrapping a bz2 compressor, while permitting pretty much anything else. It doesn't seem easy to do that in a way that avoids loopholes. (Comments on this are welcome from anyone.) \$\endgroup\$ – Nathaniel Dec 30 '17 at 12:46
  • 1
    \$\begingroup\$ You can't disallow "trivial" things, only discourage them. That's not really a problem - the real problem is they get more upvotes than they deserves, and solutions which the OP actually put effort in writing get less upvotes. \$\endgroup\$ – user202729 Dec 30 '17 at 13:02
  • \$\begingroup\$ @user202729 I can't disallow trivial things in general, but I can write the rules in such a way that specific types of trivial solution are not permitted. If I had disallowed built-in compression in paint Starry Night then it would have been a much better challenge (albeit possibly less epic in the long run, since the non-trivial answers made a good effort at keeping up with the trivial ones). Basically I don't want the winning answer to just be a shell script that runs bzip on its input. \$\endgroup\$ – Nathaniel Dec 30 '17 at 13:19
  • \$\begingroup\$ Anyway I've changed the wording of the rule - I'm not sure if the new version will work but we'll see if people have comments. \$\endgroup\$ – Nathaniel Dec 30 '17 at 13:20
  • \$\begingroup\$ Instead of stating something like "If for some reason your language or libraries include a feature that outputs some or all of the text of Hamlet, you may not use that feature." you could actually require the program to work for any input and only use Hamlet to get the scoring, this would elegantly close up that loophole but I'm sure people will find a way around this.. As you noted yourself this is a difficult task to solve. \$\endgroup\$ – ბიმო Dec 30 '17 at 14:00
  • \$\begingroup\$ @BruceForte I think I prefer the direct approach for that point. If I ask it to work for other inputs I open up the quagmire of trying to define what that should mean and how to test for it. However that's achieved I would likely still need the "if for some reason" rule, because there would probably still be ways to take advantage of a built-in database of Shakespeare plays if some language out there happens to include one. I think banning Shakespeare built-ins is unproblematic - my problem is more how to ban bz2 and the like without accidentally also banning common language features. \$\endgroup\$ – Nathaniel Dec 31 '17 at 2:26
  • \$\begingroup\$ "in the end I wish I hadn't" ... Why? What's the difference? \$\endgroup\$ – user202729 Jan 1 '18 at 9:06
  • \$\begingroup\$ @user202729 it would have been a better challenge. The best scoring answers would have been the cleverest ones that took the most effort, and there would be more motivation for people to continue doing cleverer things to beat the lowest score. If that doesn't seem desirable to you then fair enough, but it's what my taste is and it's the kind of challenge I want to design. \$\endgroup\$ – Nathaniel Jan 1 '18 at 9:15
  • \$\begingroup\$ How can you be so sure (without testing it)? bz2 developers definitely put a lot of efforts into writing their lossy image compression algorithms, so they may win. Not to mention that their code are not bytecount-limited. \$\endgroup\$ – user202729 Jan 1 '18 at 9:21
  • \$\begingroup\$ @user202729 I'm not sure what you mean. If you're referring to the Starry Night challenge I can be sure because I have tested it. Just look at the existing answers - some are really really nontrivial and use genetic algorithms, deep neural networks and other clever techniques, whereas others simply wrap an image in BPG or FLIF format and call an existing function to decompress it. There is some golfing and file type knowledge involved in this, but it's trivial compared to the other type of answer. Unfortunately the latter type did win, and that's exactly what I'm trying to avoid this time. \$\endgroup\$ – Nathaniel Jan 1 '18 at 9:29
  • \$\begingroup\$ (The clever answers on Starry Night exist in large part because I offered a series of bounties to answers that passed various milestones without using built-in compression. I could do that again this time, but I have only 2100 rep to give away, and in any case it's much more elegant if the challenge provides that motivation by itself.) \$\endgroup\$ – Nathaniel Jan 1 '18 at 9:36
0
\$\begingroup\$

Your Task:

To create a piece of code that takes in an input, and outputs ASCII art, which is encoded in the input string.

It seems unclear, but you are basically creating your own programming language that takes a piece of code in a syntax that you create, and then writing a code that takes that input, and turns it into ASCII art.


Example:

A simple example would be an input that runs through a line of input code with the syntax:

0 : An empty space
1 : A space that is occupied
2 : A newline character

I:

01010210101201010210101201010

O:

 The '|' character is just to show the matrix

| # # |
|# # #|
| # # |
|# # #|
| # # |

I:

11112000121111210002111122 // Shows a 2
11112100121001210012111122 // Shows a 0
0120120120120122 // Shows a 1
11112100121111210012111122 // Shows an 8

O:

####   
   # 
#### 
#  
#### 

####
#  #
#  #
#  #
####

 #
 #
 #
 #
 #

####
#  #
####
#  #
####

The code would read through the letters one by one and print out the characters, or create a newline character as expected.


Since this is , the code with the fewest bytes wins!

| |
\$\endgroup\$
  • \$\begingroup\$ Jelly, 0 bytes - is that what you meant? \$\endgroup\$ – user202729 Jan 6 '18 at 12:08
  • 1
    \$\begingroup\$ This is currently very unclear. As far as I see, you say we need to write code which decodes some input string to some output string. But what exactly is the decoding? Your 0,1,2 substitution seems to be an example only. \$\endgroup\$ – Laikoni Jan 6 '18 at 12:09
  • \$\begingroup\$ I think this would be pretty much trivial in most languages. Expect a lot of 2-3 byte answers. Might want to make it a bit more complex \$\endgroup\$ – Darren H Jan 6 '18 at 18:01
0
\$\begingroup\$

Stem and Leaf

A stem-and-leaf plot is a way to represent data and visualizing distribution. Usually the data is grouped in step of 10, with the last digit as "leafs" in ascending order, and the remaining digits as "stem". The steam and leafs are separated with a vertical line, with stem on the left and leafs on the right.

Challenge

Make a program or function which takes a list of non-negative integers as input, and outputs the corresponding stem-and-leaf plot.

Example Input and Outputs

Example 1:

Input: 10 2 15 4 2 24 18 17 24 24 25 15 18 22 17 23 24 33 19 28 28 28 26 32 25 27 37 28 41 38 38 30 35 30 41 45 40 40 37 33

Output:

0|224           
1|05577889      
2|23444455678888
3|0023357788    
4|00115

Example 2:

Input: 112 101 116 99 99 107 101 99 115 112 114 128 115 119 125 160 148 147 159 147 169 160 163 160 160 163 162 164 160 173 84 92

Output:

 8|4
 9|2999       
10|117       
11|2245569   
12|58        
13|
14|778       
15|9         
16|0000023349
17|3

Rules

  • The input may be a list, an array, a space or comma delimited string or other appropriate representation containing raw data values.
  • The vertical line of the output must be aligned.
  • A leading or trailing newline, or trailing spaces for each line are accepted.
  • Common loopholes applied.

This is a challenge, so the lowest-byte solution for each language wins!

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

Imagine you're a dishonorable scientist trying to prove that getting heads on a coin flip actually has about 70% probability when flipped 100 times. The trick is, you're going to flip the coin an arbitrarily large number of times (say, a million) and select the slice of 100 flips that contains the most number of heads. As input, take the number of total trials to do, and as output, return the number of heads contained within the most favorable contiguous slice of 100.

| |
\$\endgroup\$
  • 5
    \$\begingroup\$ Please "Write your challenge just as you would when actually posting it.". If you post the challenge like this you will get a lot of problems. \$\endgroup\$ – user202729 Jan 26 '18 at 5:55
  • 1
    \$\begingroup\$ (question title, winning criteria, tags, example input/output, everything you didn't have) \$\endgroup\$ – user202729 Jan 26 '18 at 5:58
  • \$\begingroup\$ I like the idea, but the correctness of the answer is a little hard to verify. Perhaps you should require the answer writers to explicitly indicate how the program does the required job, unless it's really obvious from the code. For example, someone may directly draw a value from the resulting distribution without actually generating the total number of trials. That should be acceptable, as long as the writer justifies that their approach is correct, that is, gives the exact required distribution for the output \$\endgroup\$ – Luis Mendo Jan 28 '18 at 16:54
0
\$\begingroup\$

Find a Path of Similar Proportions!

Given a point on a square lattice, find the shortest path (by jumps) from the origin to that point, following these rules:

  • You are allowed to make any number of jumps containing any number of steps along the grid lines to another lattice point. These jumps must be along the grid lines and have an integer length.
  • Each jump must contain one step more or be one step shorter than the step before it. (This is where the "similar proportions" comes into play. Name change pending?)
  • The first step can have any length.

As an example, here is how one possible way one might travel from A(0,0) to B(5,5) under these rules:

A
|
|
|
1----2
     B
     |
     |
     3

The numbers indicate which steps are taken. Note that this solution backtracks, moving to (5,8) before partially retracing its path to get to its destination. This solution takes four jumps and is therefore optimal.

Here is a diagram of the number of jumps required for the shortest (or is it?) path to any other point with both integer coordinates below or equal to 10. Note the symmetry around (x,x). I don't know if my solution for (7,10) is optimal.

  | 0  1  2  3  4  5  6  7  8  9  10
--------------------------------------
0 | 0  1  1  1  1  1  1  1  1  1  1
1 | 1  3  2  3  3  3  3  3  3  3  3
2 | 1  2  3  2  3  3  3  3  3  3  3
3 | 1  3  2  3  2  3  3  3  3  3  4
4 | 1  3  3  2  4  2  3  3  3  3  3
5 | 1  3  3  3  2  4  2  3  3  3  3
6 | 1  3  3  3  3  2  4  2  4  3  3
7 | 1  3  3  3  3  3  2  4  2  4  5?
8 | 1  3  3  3  3  3  4  2  4  2  4
9 | 1  3  3  3  3  3  3  4  2  4  2
10| 1  3  3  4  3  3  3  5? 4  2  4

The actual actual task

Your task is to continue the table for points with coordinates as large as (127,127).

Your submission should be a program which prints valid paths for all points whose two coordinates lie between 0 and an inputted positive integer inclusively, or a function, which, given any pair of positive integers, outputs a valid path to the point specified by these coordinates.

A valid output path is an array or list (or other comparable datatype) which uniquely represents a valid sequence of jumps that can be used to reach the specified point and which makes it as easy as possible to find the number of jumps required.

Example possible ways for the example path given above:

[["d", 4], ["r", 5], ["d", 4], ["u", 3]] // using chars to represent direction
[[0, 4], [5, 0], [0, 4], [0, -3]] // direction vectors
[0, 4, 5, 0, 0, 4, 0, -3] // As above, in just one list. len()/2

Scoring

Your submission will be scored by the sum of your solution's bytecount and the sum of all jump counts for all paths it outputs for reaching any point between (0,0) and (127,127), inclusively. Smallest score wins, standard rules and loopholes apply, etc...

Example response (Python 3):

def c(a,b):
    d,e,g=[[a,0]],a+1,0
    while not g==b:
        d.append([0,e])
        e,g=-e+1,g+e
    return d

This extremely simple and naive piece of Python code achieves a score of 92 (program length) + 1406272 (for the path part) = 1406364, as verified here - Try it online!

More?

  • missing tags?
  • clarifications?
  • Table is incorrect?

Please respond.

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

Collectables, Inc

You're an aspiring collector. You want to be the top collector for as many collections as possible.

Here's how you play (with P players):

  • The game consists of multiple Auctions, and 2P collections. Some collections are bigger than others. Smaller collections are more valuable and rare, bigger collections are cheaper.

  • Each Auction puts 2P random items up for sale

  • You place a bid on each item, grouped by collection. (e.g. If doll was a collection, you place a single bid for all of the dolls in the current Auction)

  • You win by having the most pieces for the most collections. (Each collection is worth 1 point. If you have the plurality of that collection, you gain that point).

Fine Details:

  • Players start with 30 gold.

  • Each collection contains a different number of items, from 2 to 2P+1.

  • There are 2P+3 auctions (until all items are sold)

  • Players can bid on multiple items, and their total bid can exceed their current gold.

  • Resolution of bids happens as follows:

    1. All invalid bids are removed. (Players without enough gold, or bids on items already sold).
    2. Find the top bid (by gold). Tiebreaker is the collection size (smallest first).
    3. If there is still a tie, then that item group is removed.
    4. Otherwise, the top bidder wins the item group. His money is added to the pot.
  • After an Auction is finished, the pot is evenly distributed among all players. Any remainder is put back into the pot.

I think that my rules are pretty complete.

  • Is it clear?
  • Is it interesting?
  • How many reads did it take you to understand the post?
| |
\$\endgroup\$
  • \$\begingroup\$ 1. It took me until the third read-through to understand that the collections are split into items and then recombined, possibly because I'm unconsciously applying real-world knowledge about how these things normally work. Explicitly saying that there are P*2+3 auctions would be a useful hint. 2. I was going to say that point 3 was missing a tie-breaker until I realised that the second sort criterion is collection size and not group size. 3. I think there's some interesting game theory here: things like weighting bids towards odd sized collections vs even sized collections. \$\endgroup\$ – Peter Taylor Sep 11 '17 at 7:37
  • \$\begingroup\$ @PeterTaylor thanks for the feedback! I added an overview, does that help? \$\endgroup\$ – Nathan Merrill Sep 11 '17 at 15:32
  • \$\begingroup\$ Best to ask someone who hadn't previously read the question. BTW I presume you're planning to add something later about the I/O? \$\endgroup\$ – Peter Taylor Sep 11 '17 at 16:01
  • \$\begingroup\$ Yep. There isn't any hidden information (unless you count simultaneous as hidden), so the API should be pretty straightforward. \$\endgroup\$ – Nathan Merrill Sep 11 '17 at 16:21
0
\$\begingroup\$

Unicode reversible programs

The goal is to make a program that includes unicode formatting characters that when executed as-is generates a OEIS sequence, and when copied as its rendered* and executed, returns a different sequence.

  • The renderer is one that properly reacts to unicode formatting. For example with RLO the text should be reverted. (Its stored as "\u202etest" but renders as "tset"

This is will be so the answer with less bytes wins.

| |
\$\endgroup\$
  • 3
    \$\begingroup\$ What do you mean by "copied as its rendered and executed"? \$\endgroup\$ – Peter Taylor Feb 1 '18 at 11:18
  • \$\begingroup\$ @PeterTaylor I mean that for example the text "\u202e hello" is rendered as "olleh " because U+202E is a unicode control character that reverses text (when rendered) \$\endgroup\$ – iovoid Feb 1 '18 at 19:28
  • \$\begingroup\$ Define it objectively. How browsers/text editors handle copy-paste are implementation-defined. (which browsers/text editors, which exact ways to copy-paste, put the pointer on which pixel of the screen, etc.) \$\endgroup\$ – user202729 Feb 2 '18 at 5:35
  • \$\begingroup\$ U+202E is not a Unicode control character: the Unicode control characters are the ranges U+0000 to U+001F and U+007F to U+009F. \$\endgroup\$ – Peter Taylor Feb 2 '18 at 12:19
  • \$\begingroup\$ Also: this question talks about characters and bytes but it doesn't address the relationship between them, which is a minefield. What about languages which don't use UTF-8 or UTF-16 for their source? What about languages which use either according to a command-line flag: can the transformed program change the state of that flag? \$\endgroup\$ – Peter Taylor Feb 2 '18 at 12:26
  • \$\begingroup\$ @PeterTaylor languages that dont use utf-8 it in their source can use a escaped form such as (0xe2 0x80 0xae). Also thanks for pointing that its actually a formatting character (not control) \$\endgroup\$ – iovoid Feb 2 '18 at 18:20
  • \$\begingroup\$ So basically split on the unicode char and reverse all that's after it? Possibly multiple times? Doesn't sound too interesting. \$\endgroup\$ – Magic Octopus Urn Feb 2 '18 at 21:29
  • \$\begingroup\$ "for example"? Questions (challenges) need to be self-included. List all of them please. \$\endgroup\$ – user202729 Feb 3 '18 at 5:29
0
\$\begingroup\$

Non-true, non-false JS boolean

Array prototype isn't redefined, input hasn't getters

function magic(input){
  let result = [];
  if(input.boolean != true){result.push("non-true");}
  if(input.boolean != false){result.push("non-false");}
  result.push(input);
  return result.join("\n");
}

returns

non-true
non-false
{"boolean": true}

What is passed to magic function?

Based on real problem :) I spent 30 minutes on this puzzle

| |
\$\endgroup\$
  • 5
    \$\begingroup\$ This site is for programming contests, not pure programming puzzles. Thanks for using the sandbox, anyway. \$\endgroup\$ – user202729 Feb 1 '18 at 12:11
  • 7
    \$\begingroup\$ Contrary to what user202729 states, Programming Puzzles are on-topic on this site. This challenge could use a little cleanup to make it a better fit here (for example, what language is this?), but this challenge is indeed allowed here. \$\endgroup\$ – AdmBorkBork Feb 1 '18 at 14:02
  • \$\begingroup\$ ... someone said that I'm wrong. Anyway people definitely doesn't like this. \$\endgroup\$ – user202729 Feb 1 '18 at 14:02
  • \$\begingroup\$ @AdmBorkBork this is JS \$\endgroup\$ – Евгений Новиков Feb 1 '18 at 14:41
  • 3
    \$\begingroup\$ @ЕвгенийНовиков what JS version is this? in is a keyword, and can't be a variable name. \$\endgroup\$ – dzaima Feb 1 '18 at 14:47
  • \$\begingroup\$ @dzaima Good point. Last time I check on TIO the object {boolean: true} doesn't have " around and it caused a syntax error. I forgot about in so just try to rename it and it worked... \$\endgroup\$ – user202729 Feb 1 '18 at 14:51
  • \$\begingroup\$ "Programming Puzzle" is in the name of the site @user202729 \$\endgroup\$ – dylnan Feb 1 '18 at 15:46
  • \$\begingroup\$ @dylnan But... \$\endgroup\$ – user202729 Feb 1 '18 at 15:55
  • \$\begingroup\$ @AdmBorkBork is correct. We do allow programming puzzles. \$\endgroup\$ – Nathan Merrill Feb 1 '18 at 16:25
  • \$\begingroup\$ @NathanMerrill Then just upvote the comment. \$\endgroup\$ – user202729 Feb 2 '18 at 5:34
  • \$\begingroup\$ Many many things in the past, including but not limited to, code-trolling, underhanded, non-observable behavior, etc. are off-topic or heavily-discouraged nowadays. Be careful. \$\endgroup\$ – user202729 Feb 2 '18 at 5:34
  • \$\begingroup\$ @user202729 I did upvote. I just wanted to make sure it was extra clear to the OP. Furthermore, this challenge doesn't fit any of those tags, because its not asking for trolling/underhanded/non-observable code. You could argue that the code in the challenge fits those tags, but that's not what we care about. \$\endgroup\$ – Nathan Merrill Feb 2 '18 at 5:51
  • 2
    \$\begingroup\$ I don't believe that console is part of any JS spec. This presumably only works in certain contexts, and the question should specify what they are. Otherwise the task devolves into code-trolling by defining a suitable console. It's already borderline IMO. \$\endgroup\$ – Peter Taylor Feb 2 '18 at 12:04
  • \$\begingroup\$ @dzaima sorry, fixed this. Now input variable is input \$\endgroup\$ – Евгений Новиков Feb 3 '18 at 7:40
  • 1
    \$\begingroup\$ OK, so, in that case you may want to work on the wording of the challenge before posting it to Main because, right now, it reads as though you've come across this challenge elsewhere, spent half an hour trying to solve and are now looking for help doing so. Also, just so you know, restricted language challenges rarely go down well here. \$\endgroup\$ – Shaggy Feb 3 '18 at 19:20
0
\$\begingroup\$

Tags: Codegolf

Title: evil detection

When given any (you may choose the format and you should assume integer input) input, the output should be true if the input is a palindrome and false if not (or 1/0 or any equivalent).

To make it (a lot) harder, your code must work with a result that fulfills the challenge inverted if read backwards. So for a palindrome input, forward gives true, backwards false.

Example:

If your code is "abc12" and the input is 1221, your code should produce true-ish and "21cba" (your code read backwards) should produce false-ish.

Bonus if you think that's to easy: produce false if and only if the input is 666 forward and true backwards.

| |
\$\endgroup\$
  • 2
    \$\begingroup\$ Duplicate \$\endgroup\$ – Shaggy Feb 5 '18 at 16:58
  • \$\begingroup\$ First, I want to say thanks for using the sandbox! Also, I do think you could go somewhere with this idea that doesn't make it a duplicate. Your idea is marginally different, in that it only requires the code to behave the same forward and backwards, rather than actually be a palindrome. While I think for palindromes it will almost always be best to have a palindrome, perhaps you can think of a different pattern that makes it more interesting? I'll let you know if I think of anything. \$\endgroup\$ – FryAmTheEggman Feb 5 '18 at 22:23
  • \$\begingroup\$ @FryAmTheEggman, I don't think the fact that the code need not be palindromic is enough to make this not be a dupe; many of the solutions to the challenge above would also be the optimal solution here. Maybe if this one required that the code not be a palindrome and also required that it output a different pair of consistent and distinct values when run in reverse, it might be enough to differentiate it? \$\endgroup\$ – Shaggy Feb 6 '18 at 9:25
  • \$\begingroup\$ Thanks to both of you, I'll have a look at the other answers, but I agree that allowing the code to be semi-palindromic is not enough (unless the other answers are all extremely long, I haven't looked yet). I'm thinking about making the code required to not be symmetric, but haven't figured out what to do with the input to make it fit \$\endgroup\$ – DonQuiKong Feb 6 '18 at 9:28
  • \$\begingroup\$ @Shaggy That seems like a good start for changing it. For the record, I definitely think that as it was when I posted it was a duplicate, I just thought there was something good in this challenge and I didn't want it to just be discarded! The unfortunate thing about just requiring non symmetry is that comments/newlines could often just be added at the end without much cost, but I do think there is a good challenge here, somewhere. \$\endgroup\$ – FryAmTheEggman Feb 6 '18 at 18:39
  • \$\begingroup\$ @fryamtheeggman how about this? \$\endgroup\$ – DonQuiKong Feb 6 '18 at 18:59
  • \$\begingroup\$ I think the problem with this is that while some of the answers to the other question will no longer work, some are still usable here with only a slight modification, so I don't think this will cut it. \$\endgroup\$ – FryAmTheEggman Feb 6 '18 at 19:31
  • \$\begingroup\$ @Fryamtheeggman and if I make the bonus question mandatory? But I'll think some more \$\endgroup\$ – DonQuiKong Feb 6 '18 at 19:42
0
\$\begingroup\$

Build a Brainfuck transpiler

Your job is to build a program that transpiles valid brainfuck to a language (not brainfuck!) of your choice.

You are not required to handle cases where the program is invalid (mismatched [ ]s), or contains characters that are not +-<>[],. but all other cases must be handled.

Size limits on your input or output are fine as long as they are imposed by computer restrictions, like RAM.

The programming language you transpile to is covered under the "What defines a programming language" rules, and must have been created before this challange.

In extension to not transpiling to brainfuck (cheater!) you can't use a brainfuck derivative or trival brainfuck substitution as the transpiled to language either.

Scoring

Programs will be scored with the average ratio of bytes in the input brainfuck program to the output transpiled result, as based on the examples.

Meta questions

This is a rough draft!
What tags should be associated with this?
How can I improve the scoring system?
What examples should I use to keep the scoring fair, but prevent obvious tricks?
What loopholes are there in this rough draft that I need to patch?

This entire thing will be reorganized when I get enough info to make a better writeup.

| |
\$\endgroup\$
  • \$\begingroup\$ I'd tag it with code-challenge and brainfuck. Once you post the examples the scoring system seems to be fine, the major problem would be hardcoding but this is a standard loophole, so this should be fine. Also you should probably consider adding a non-terminating example. About preventing brainfuck derivatives: I'm not sure if this is well-defined enough, maybe others have some ideas? \$\endgroup\$ – ბიმო Feb 10 '18 at 14:22
  • \$\begingroup\$ @BMO About hardcoding: Just hide the official test cases. You don't need to prevent BF derivative, they would just be boring (and downvoted most likely). Also it's very hard to define them (What about 2D BF? What about Unary? What about Random BF / self-modifying BF?) \$\endgroup\$ – user202729 Feb 10 '18 at 15:39
  • \$\begingroup\$ Also, BF is too unclear as a language specification. (is memory wrapping or infinite to one end or infinity to both ends? Are values positive/negative/modulo 256? etc.) \$\endgroup\$ – user202729 Feb 10 '18 at 15:41
0
\$\begingroup\$

Chiasmus Indenter


Chiasmus is a literary form that is similar to palindromes. Some ideas are presented and then presented again in reverse order, often phrased differently.

Natural language processing is hard, so I'll be using a more computer-friendly definition. A chiasmic string is made up of a series of substrings that are repeated in reverse order in the second half of a string. Formally:

  • If a is some non-empty string, then aa is chiasmic.
  • If C is chiasmic and a is some string, then aCa is also chiasmic. Note that this applies recursively, thus abCba is chiasmic if C is also chiasmic and a and b are non-empty strings.

For example, batbat is chiasmic, as are glassbottlebottleglass and AliceBobCharlieCharlieBobAlice. All even-length palindromes are chiasmic, being made up of many length-1 strings.

Note that the empty string is not a chiasmus.

The Challenge

We're programmers, so we like nice indentation. Your goal is to take chiasmic strings and indent them so that each matching substring is at the same level of indentation. For example, cheesepizzawithanchoviesanchovieswithpizzacheese would be indented like so:

cheese
    pizza
        with
            anchovies
            anchovies
        with
    pizza
cheese

For base case chiasms (i.e. 2 repetitions of a string), no indentation is necessary, but the substrings should still be on separate lines. Thus, gumgum would be indented:

gum
gum

In order for there to be only one canonical output for each chiasmus, if it is possible to indent at more than one place, indent in a way such that the a substrings for the form aCa are as long as possible (applied recursively for each C until the aa base case is reached). For example, catdogcatdogdogcatdogcat should be indented like this:

catdogcat
    dog
    dog
catdogcat

Not like this:

cat
    dog
        cat
            dog
            dog
        cat
    dog
cat

Also not like this:

cat
    dogcatdog
    dogcatdog
cat

The behavior of indenting a non-chiasmus is undefined.

Rules

  • Indentation can use any amount of whitespace of any kind, so long as it is consistent (e.g. do not mix tabs and spaces). Lines may either be output as a list/array/whatever or a newline-separated string.
  • You may assume that the input is a chiasmus that contains only alphanumeric characters.
  • As this is , the shortest submission wins.
| |
\$\endgroup\$
  • \$\begingroup\$ May indentation be done with a \t character? \$\endgroup\$ – Kamil Drakari Feb 9 '18 at 22:25
  • \$\begingroup\$ I probably should do that since it saves 2 characters and is purely cosmetic. \$\endgroup\$ – Beefster Feb 9 '18 at 22:43
  • \$\begingroup\$ "Longest possible substrings" still leaves some room for ambiguity. What's the canonical output for ababbaba? \$\endgroup\$ – Nitrodon Feb 10 '18 at 4:40
  • \$\begingroup\$ aba b b aba. I see how it can be indented as a bab bab a, though. \$\endgroup\$ – Beefster Feb 10 '18 at 6:44
  • \$\begingroup\$ I kept waiting for a glassbottlebottleglass test case! \$\endgroup\$ – Shaggy Feb 11 '18 at 9:27
  • \$\begingroup\$ @Shaggy Wish granted. \$\endgroup\$ – Beefster Feb 11 '18 at 16:52
  • \$\begingroup\$ I don't understand the catdogcatdogdogcatdogcat example. It seems to me to directly contradict the rule it's supposed to be illustrating. \$\endgroup\$ – Peter Taylor Feb 12 '18 at 8:54
  • \$\begingroup\$ @PeterTaylor how so? \$\endgroup\$ – Beefster Feb 12 '18 at 20:15
  • \$\begingroup\$ On review, I agree that "directly contradict" is overstating it. But the minimalist indentation still doesn't fit the rest of the question. The stated grammar is pointless: the derivation aCa is only permitted for extremely limited values of C (strings of the form bb such that there aren't c and d satisfying ab = cd and |c| > |a|). The statement "indent in such a way that the lowest levels of indentation have the longest strings possible" (my emphasis) makes no sense, because there is at most one level of indentation (or two if you count "unindented" as the first). \$\endgroup\$ – Peter Taylor Feb 12 '18 at 21:49
  • \$\begingroup\$ And the statement "All even-length palindromes are chiasmic, being made up of many length-1 strings" is not true, because the canonicalisation forces it to be made up of one repeated length-1 string and an outer layer of a repeated length-(n-2)/2 string. \$\endgroup\$ – Peter Taylor Feb 12 '18 at 21:50
  • \$\begingroup\$ The aCa form is recursive. Maybe I should make that clearer with the examples. \$\endgroup\$ – Beefster Feb 13 '18 at 1:53
  • 1
    \$\begingroup\$ I would suggest dropping the requirement to produce an error on non-chiasmal(?) input, and instead just guarantee that the input will be a chiasmus. This changes it from two challenges (detect whether the input is a chiasmus, and then indent it if it is) to one (indent a chiasmus). Just my opinion though. \$\endgroup\$ – Nathaniel Feb 13 '18 at 7:56
  • 1
    \$\begingroup\$ Slightly related \$\endgroup\$ – Shaggy Feb 13 '18 at 10:16
  • \$\begingroup\$ @Shaggy Well yeah it's related. I created that challenge and it was a direct inspiration for this one. \$\endgroup\$ – Beefster Feb 13 '18 at 19:30
0
\$\begingroup\$

Self-removing executable (retracted: dupe)

| |
\$\endgroup\$
  • \$\begingroup\$ I don't like the restriction, it makes it easier for you to test (I guess that's the point of it?), but it prevents me (and many others) from competing. Saying it must handle "long and unusual characters" is underspecified. You can say that the program must be able to handle any valid filename, in the chosen operating system. The example code is already very short, so it doesn't leave much room for golfing, with all the restrictions in place. \$\endgroup\$ – Stewie Griffin Feb 14 '18 at 11:03
  • \$\begingroup\$ Which restriction? Shall it be centered around per-language leaderboard then? \$\endgroup\$ – Vi. Feb 14 '18 at 11:13
  • \$\begingroup\$ Always per-language. I guess t's not all restrictions, but all the Linux-specific stuff. Keep in mind that these are only my opinions though, others might disagree. \$\endgroup\$ – Stewie Griffin Feb 14 '18 at 11:22
  • \$\begingroup\$ It could be a good idea to have it Linux specific, but the example code is already so short that it leaves very little room for creativity. \$\endgroup\$ – Stewie Griffin Feb 14 '18 at 11:23
  • 1
    \$\begingroup\$ Dupe: codegolf.stackexchange.com/questions/19355/… ? \$\endgroup\$ – user202729 Feb 14 '18 at 12:52
0
\$\begingroup\$

Convert a number to (Name-To-Be-Specified)

(Name-To-Be-Specified) is a completely made up language. It uses a Senary (base 6) system of numbers with words for those numbers structured in a similar way to English.

0 to 6
Single digit numbers use a single word for each digit.

0 = "zeeroo"
1 = "nimbo"
2 = "feta"
3 = "tarumba"
4 = "ntamno"
5 = "waramaka"
(Any similarity to Kómnzo numbers are coincidental.)

6 to 11
The first set of two-digits numbers have special rules.

6 = "wi"
7 = "seeveen"
8 = "ayte"
9 = "tarumbawin"
10 = "ntamnowin"
11 = "waramakawin"

12 to 35
Multiples of 6 have the single digit word with a "wee" suffix.

12 = "fetawee"
18 = "tarambawee"
24 = "ntamnowee"
30 = "waramakawee"

Other numbers in this range are made by joining the word for the multiple of 6 with the word for single digit number, separated by a space. For example:
13 = "fetawee nimbo"
20 = "tarambawee feta"
27 = "ntamnowee taramba"
34 = "waramakawee ntamno"

36 to 1295
1296 to 46655
46656 to 1679615
1679616 to 60466175
(Since this is a sandbox, I'll leave these to-be-specified for now. Suffice to say I'll come up with words for each and consistent rules for joining them together and when you need the word "and".)

Challenge

Write a program that takes an integer as input and outputs that number in (Name-To-Be-Specified) words as described above. Shortest code wins.

| |
\$\endgroup\$
  • \$\begingroup\$ A language called Golfish already exists >_< \$\endgroup\$ – Mr. Xcoder Feb 23 '18 at 13:50
  • \$\begingroup\$ @Mr.Xcoder I believe you mean Gol><> \$\endgroup\$ – user45941 Feb 23 '18 at 13:52
  • \$\begingroup\$ That's a programming language, not a spoken language. But fair point, if I graduate this to an actual question I'll pick a new name. \$\endgroup\$ – billpg Feb 23 '18 at 13:52
  • \$\begingroup\$ @Mego Well yeah but the repository name is Golfish... \$\endgroup\$ – Mr. Xcoder Feb 23 '18 at 13:53
  • \$\begingroup\$ Anyway, I'd advise referencing that you're not referring to Gol><> in any way. :) \$\endgroup\$ – Erik the Outgolfer Feb 23 '18 at 13:54
1
73 74
75
76 77
99

You must log in to answer this question.

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