458
\$\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\$
  • \$\begingroup\$ How are tags added to questions? \$\endgroup\$ – guest271314 Jan 9 at 7:51
  • \$\begingroup\$ @guest271314 You can use this markup to create a tag in a draft: [tag:code-golf] \$\endgroup\$ – DJMcMayhem Aug 29 at 15:19
  • \$\begingroup\$ Why no featured anymore? Can't we have it auto-added or something? \$\endgroup\$ – JL2210 Sep 26 at 15:57
  • 1
    \$\begingroup\$ @JL2210 We now have a permanent info box that links to the Sandbox, so the featured tag isn't necessary \$\endgroup\$ – caird coinheringaahing Sep 29 at 13:43
  • \$\begingroup\$ I think the sentence 'replace the post here with a link to the challenge and delete it' may specify that the deletion should be done immediately . \$\endgroup\$ – AZTECCO Oct 5 at 19:39

2561 Answers 2561

0
\$\begingroup\$

Bomb Drops

[tag:???]

The Challenge

Your task is to create a program that simulates "dropping bombs" on a 2 dimensional array.

For example consider the following 2d array:

3 0 5 0 5
5 3 4 0 2
1 0 5 4 2
2 4 2 3 2
2 3 3 0 0

Dropping a bomb on a single cell decreases the value of that cell by 2 and the value of its direct neighbors (including diagonal neighbors) by 1, to a minimum of 0.

If we were to drop on a bomb on the cell corresponding to array[2][1] where the value is 4, or coords (2,1), then the new 2d array would look like so:

3 0 4 0 5
5 2 2 0 2
1 0 4 3 2
2 4 2 3 2
2 3 3 0 0

Input

Your input will be a two dimensional array of integers greater than or equal to zero, in whatever way you like.

You will then also take input that is a sequence of tuples, lists of size 2, or whatever else you please that corresponds to coordinate points. For example,

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

For each of these points, you will simulate a bomb drop on that point. You do not need to worry about these coordinates being out of range of the 2d array.

Output

Output consists of a two-dimensional array, formatted the way you please.

Test Cases

>>> [[0, 1, 3, 1, 1], [3, 5, 1, 0, 4], [1, 1, 1, 0, 2], [1, 2, 0, 3, 4], [5, 2, 0, 2, 2]]
# 0 1 3 1 1
# 3 5 1 0 4
# 1 1 1 0 2
# 1 2 0 3 4
# 5 2 0 2 2
>>> [3,4],[2,1],[0,0]
0 0 2 0 1
2 3 0 0 4
1 0 0 0 2
1 2 0 2 3
5 2 0 0 1

# You can also take input in one pass, rather than 
# having the 2d array and the coordinates be seperate inputs:
>>> [[5, 2, 3, 0, 3], [4, 3, 5, 5, 5], [1, 3, 3, 3, 3], [0, 1, 2, 3, 1], [3, 1, 2, 2, 4]],[2,2],[0,1],[3,3]
# 5 2 3 0 3
# 4 3 5 5 5
# 1 3 3 3 3
# 0 1 2 3 1
# 3 1 2 2 4
4 1 3 0 3
2 1 4 4 5
0 1 0 1 2
0 0 0 0 0
3 1 1 1 3

Other info

Inspired from this question on StackOverflow.


This is my first challenge, I'm looking for any advice at all. I'm not sure what other tags to put aside from code golf. I'm probably missing a few basic rules etc too that I've forgotten about. All suggestions welcome.

\$\endgroup\$
  • \$\begingroup\$ This looks like a pretty good challenge, but I'd consider rewriting the parts about "bomb dropping." This is just my opinion, but I feel like adding deadly weapons to an otherwise lighthearted post about programming detracts from the challenge. \$\endgroup\$ – FryAmTheEggman Aug 11 '16 at 15:27
  • \$\begingroup\$ @FryAmTheEggman It makes for a good clickbait title though :P \$\endgroup\$ – Theo Aug 11 '16 at 15:33
  • \$\begingroup\$ @FryAmTheEggman Fair point, what would you suggest? \$\endgroup\$ – Justin Aug 11 '16 at 15:37
  • \$\begingroup\$ You could consider something like "fill up the holes" where bombs are replaced by bags of dirt and the numbers are depth below ground level or "clean up the garbage" where you grab from piles that are nearby each other. Unfortunately I'm having trouble coming up with something quite as evocative as bombs are. If you can't come up with a good replacement, I wouldn't worry too much about my original comment, as there's nothing actually wrong with your post. I just felt the tone was kind of off. \$\endgroup\$ – FryAmTheEggman Aug 11 '16 at 15:52
0
\$\begingroup\$

Paint with all the colors of the RGB rainbow

Inspired by Images with all colors and American Gothic in the palette of Mona Lisa: Rearrange the pixels

Given an input raster image, output a raster image where each pixel is a unique color, such that the sum of the absolute value of the sum of the differences of the RGB channel values for each pixel between the original image and the output image is minimized. In other words, that means, given an image O, find an image X such that every pixel is a different color, and (in pseudo-Python) the quantity sum(abs(O_pixel.RED - X_pixel.RED) + abs(O_pixel.GREEN - X_pixel.GREEN) + abs(O_pixel.BLUE - X_pixel.BLUE) for O_pixel,X_pixel in zip(O.pixels, X.pixels)) is minimized.

3-bit example

All images in this example are 4 pixels wide by 2 pixels high, magnified 40x to 160x80 so that they can be seen more easily.

Original image:

original 3-bit

The palette:

color space

The image using each color from the palette that is closest to the original (minimum sum 6):

3-bit output big

Specifications

  • All images will use 8-bit colors (3 bits in the red and green channels and 2 in the blue channel), and will be 16x16. Here is an image displaying the 8-bit color palette. Each color from this palette must be used exactly once in the output image.
  • Submissions must complete for any of the test images in under 1 minute.
  • If there are multiple optimal solutions, any one of them may be used.

Test cases

Original is on the left, expected output is on the right. All of these images are zoomed in; click the links to get the original-sized images.

Note that these two are the same, because the original image is already composed of unique pixels. Thus, the minimum sum is 0.

(more to come once my computer finishes generating them)

\$\endgroup\$
  • 1
    \$\begingroup\$ 1. If you want the test cases to be useful - and if you don't, there's no point in having them - then include the minimum sum of the absolute pixel differences. 2. I don't see the point of using images. The objective function prioritises red completely over green and green completely over blue, so there's no reason for the output image to look remotely like the input one. The interesting part of the question could be done perfectly well with integer arrays, and that would allow for much simpler I/O. \$\endgroup\$ – Peter Taylor Aug 8 '16 at 7:24
  • \$\begingroup\$ @PeterTaylor You're right on the pixel differences being dominated by the red channel - what I had in my mind was not what I typed up. I'll edit it to closer reflect my original idea that got lost in translation. \$\endgroup\$ – Mego Aug 8 '16 at 8:23
0
\$\begingroup\$

Convert Between American and British English Spellings


In this challenge, you will have to write two programs or functions. One will convert a list of words from their American English spelling to the British English equivalent, and the other to convert the other way. Here's that catch: you only have 300 bytes to do both!

The Challenge

You can find a gist here that contains a list of 1000 words. The file is formatted so each line is british-spelling(space)american-spelling. Therefore, there are only 500 words in total, each with 2 spellings. This file is for your convenience, and it was based on the list found here.

Your challenge is to write two programs or functions (has to be two programs or two functions, it can't be one program and one function). Both will take a single string as input and output a single string. The first program/function will take in British English words and output the American English spelling, and the second will take in American English words and output the British English spelling. Built-in functions or libraries that do this task are not allowed, nor are standard loopholes. You also cannot hard-code the list into your program. Your programs and functions have a shared 300 byte limit, i.e. length(program1)+length(program2)<=300. However, each program/function may be of different length.

Scoring

You will be scored based on how accurate your programs/functions were. Your score will be calculated based on the following formula:

formula

Highest score wins. Ties are broken by shortest shared byte total.


SANDBOX NOTES

  • I can't help but fell like I am missing something.
  • Should I post the gist contents here, as well as a link to it?
  • Is 300 bytes too generous, too litte, or is it fine?
  • -
\$\endgroup\$
  • \$\begingroup\$ Byte limits are frowned upon \$\endgroup\$ – Destructible Lemon Aug 15 '16 at 1:33
  • \$\begingroup\$ @DestructibleWatermelon Well, my main concern is that solutions will be able to get high or perfect scores without a byte limit. My main goal with the limit was to simply encourage use of a few creative methods that don't have really high scores rather than allowing all programs to have high scores. AKA, I want to increase the variance in the scores. \$\endgroup\$ – GamrCorps Aug 15 '16 at 1:42
  • 1
    \$\begingroup\$ @DestructibleWatermelon I don't think that's really applicable to this question - byte limits tend to be useful for test-battery for the reasons GamrCorps says. Whether 300 is generous or too little however, is hard to say without actually trying... \$\endgroup\$ – Sp3000 Aug 15 '16 at 2:01
  • \$\begingroup\$ Byte limits are redundant and unhelpful for a code golf challenge, but the meta post isn't saying byte limits are bad elsewhere. This isn't a code golf so the byte limit isn't bad for the same reason. However, I would point out that 300 bytes is very little for Java, but probably more than enough to write a fully working bilingual AI in Jelly. This isn't necessarily a problem - competition can be within languages rather than between them. However, it might be difficult to find a limit that doesn't completely exclude a lot of languages. \$\endgroup\$ – trichoplax Aug 15 '16 at 11:30
  • \$\begingroup\$ As Sp3000 points out, it will be difficult to fine tune the limit, but I do think this is an interesting challenge. There is a lot of overlap in the patterns of how British and American spellings vary, so this isn't just an arbitrary compression challenge. \$\endgroup\$ – trichoplax Aug 15 '16 at 11:36
  • \$\begingroup\$ I have no idea which would be more interesting, but just thinking: The word list could be solely words that differ between the two countries, or it could include some words that are the same in both. Does anyone have any thoughts about what effect this would have? \$\endgroup\$ – trichoplax Aug 15 '16 at 11:40
0
\$\begingroup\$

How far is it?

I have no children myself but I understand they are more interested in the destination than the journey, so often ask how much of the journey is left. This might be a car trip, or it might be a demonstration of the Tower of Hanoi puzzle.

The original aim of the puzzle is to move all the disks from one pillar to another, but except for the smallest disk (which can be moved to any pillar at any time) the only disk you can move is the lowest numbered disk on the other two pillars.

Although there is a well-known optimal sequence from one pillar to another, each of the three moves will take you slightly nearer to finishing on a different pillar. (This partly explains why there are only two available moves when all the disks are already on the same pillar.) It's therefore possible to mistakenly take a detour towards another pillar yet correct yourself and finish at your desired pillar without retracing your steps. You should therefore not assume that the input position is from the optimal sequence.

The challenge is to write a program or function that accepts three sets (arrays, lists, strings, etc.) representing the sizes of the disks on each pillar and returns an integer giving the number of steps remaining to move all the disks to the first pillar. Examples:

[1, 2, 3] [0] [] -> 1
[2, 3] [0, 1] [] -> 3
[0, 1] [2] [3] -> 11
[0, 1, 2] [] [3] -> 15

Not only must your program return the shortest number of steps possible, but it must itself also be as short as possible.

Please indicate whether your input format requires the disks in a particular order.

\$\endgroup\$
  • 1
    \$\begingroup\$ 1. Needs at least a link to an explanation of the tower of Hanoi, and preferably a short explanation in the question so that it's self-contained. 2. The test cases don't seem to cover situations where poor play has got the board into a complete mess. \$\endgroup\$ – Peter Taylor Aug 12 '16 at 10:10
0
\$\begingroup\$

The 9-hole GOLF challenge

Each of these challenges are challenges to be judged by the GOLF CPU.

Hole 1: Prime Partitions

Hole 2: Sides of a Cuboid

Hole 3:

You are given the area of a polygon, and the number of edges of the polygon. You must find the minimal perimeter of the polygon. This challenge is more about implementing floating point/decimal numbers efficiently. Your answer must be accurate to at least 3 decimal places.

10, 5:    2.41088
7, 8:     1.20405
6700, 14: 20.9027

Hole 4:

You are given a number, A, and a base B. You must take the digits of A in base B and use each digit as the power of the digits before it. Assume that integer overflow is desired. For example,

125:  ((5)^2)^1     :25
3234: (((4)^3)^2)^3 :68719476736
18043:              :1
12540:              :0

Hole 5:

We define F(n) to be equal to the sum of all previous term's digits, and F(0) = 1. Given N, you must return the value of F(N). This sequence is A004307 on OEIS

0: 1
1: 1
2: 2
3: 4
4: 8
5: 16
6: 23
20: 137

Hole 6:

You must return the Nth decimal place of e

0:  2
1:  7
5:  8
25: 4

3 more holes (To come up with)

Do these holes look reasonable? Enjoyable? Confusing?

\$\endgroup\$
  • \$\begingroup\$ On hole 2, I think you mean volume rather than area. \$\endgroup\$ – Peter Taylor Jul 1 '15 at 21:20
0
\$\begingroup\$

Remove first encountered elements from a list

Inspired by this question on Stackoverflow.


The task

Let's have two lists/arrays of integers: L1 and L2 of equal length. You need to remove from L2 the first occurrence of each number and from L1 the values on the corresponding positions. Then print/output the modified L1 and L2 (in that order). The separator between the elements of the list needs to be distinct from the separator between lists (both must not be numeric).

Since the lists can be long and have big numbers (but to your language's limits) your code needs to be as short as possible.

If (and only if) your language doesn't support lists, arrays or any similar structure, you can take the input as a string.

Example

L1 = [1 2 3 4 5 6 7 8 9]
L2 = [2 3 3 5 5 4 3 7 1]
Elements to remove from L2:
L2 = [2 3 3 5 5 4 3 7 1]
      ^ ^   ^   ^   ^ ^
Corresponding elements to remove from L1:
L1 = [1 2 3 4 5 6 7 8 9]
      ^ ^   ^   ^   ^ ^
Output result:
L1 = [3 5 7]
L2 = [3 5 3]

Test cases

Input -- Output
[1 2 3 4 5 6 7 8 9];[2 3 3 5 5 4 3 7 1] -- [3 5 7];[3 5 3]
[1 1 1];[1 2 3] -- [];[]
[2 2 2];[1 1 1] -- [2 2];[1 1]
[-1 0 2 123456];[-1 0 -1 0] -- [2 123456];[-1 0]
[1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40];[1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1] -- [2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40];[1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1]

\$\endgroup\$
  • \$\begingroup\$ While this comes from an SE question, having two arrays seems a bit odd. A more standard task is simply to remove the first occurrence from the single array. (Though, it may be a duplicate then) \$\endgroup\$ – Nathan Merrill Aug 17 '16 at 18:33
  • \$\begingroup\$ @NathanMerrill I thought of limiting it to just one array, but in my opinion this way is more challenging. \$\endgroup\$ – pajonk Aug 17 '16 at 19:01
  • \$\begingroup\$ I agree, it does increase the difficulty of the challenge. \$\endgroup\$ – Nathan Merrill Aug 17 '16 at 19:04
0
\$\begingroup\$

Enumerate Irreducible Polynomials in GF(2)[X]

Meta:

  • I noticed this is a duplicate of Find the XOR Primes
  • Would it make it a non-dupe if we'd go from q=2 to q=3?
  • Would it be more interesting for the general case, where the submissions have to take q(prime) and n

A polynomial over any finite field GF(q) of prime order q can be represented by an integral polynomial with coefficients in {0,1,2,...,q-1} ⊂ ℤ by the reduction modulo q. This allows us to easily enumerate all polynomials with coefficients in that field by using a polynomial p with coefficients in {0,1,2,...,q-1} ⊂ ℤ and evaluating it in q. So we map such a polynomial p to a nonnegative integer p(q). It is easy to show that this mapping is a bijection between the set of said polynomials and the nonnegative integers, when you consider one of those polynomials p(X) as an integer in base X.

Challenge

Let I be the set of irreducible polynomials with coefficients in GF(2), represented by integral polynomials with coefficients in {0,1}. Then enumerate all elements of {p(2) | p ∊ I} ⊂ ℤ in ascending order and let a(n) be the nth element. Given n your submission should return a(n). This is in fact A014580 in OEIS.

Examples

The irreducible polynomials in GF(2)[X] with a degree of at most 3 are: {p1(X)=X, p2(X)=1+X, p3(X)=1+X+X^2}. Substituting X by 2 results in p1(2)=2, p2(2)=3, p3(2)=7. So we see a(1) = 2, a(2) = 3, a(3)=7. Some more of those polynomials can be found on MathWorld.

Test cases

 n  a(n)
 1    2
 2    3
 3    7
 4   11
 5   13
 6   19
 7   25
20  103
34  203
35  211
50  355
53  369
54  375
\$\endgroup\$
  • \$\begingroup\$ It should be a polynomial over any finite field: the field which it's in is GF(q)[x], as per the title. I'm not sure what the point of the first sentence is: it seems to be stating a tautology. Unless it's intended to define a polynomial over a field F as a polynomial whose coefficients are in F? I'm also not sure what you mean by "evaluating it in q". As for the question about dupes: over prime-order Galois fields other than GF(2) there isn't a built-in for polynomial addition in most languages, but implementing that manually instead of with ^ is fairly minor. \$\endgroup\$ – Peter Taylor Aug 17 '16 at 21:51
  • \$\begingroup\$ @PeterTaylor Thanks for the correction. With that sentence I wanted to emphasize that it is sufficient to consider these (integer) representants of the residue classes as elements of the field. A polynomial p evaluated in q is just the image of q under the substitution homomorphism q ↦ p(q) defined by p. You "plug in a value for X". \$\endgroup\$ – flawr Aug 17 '16 at 22:04
  • \$\begingroup\$ I would call that evaluation at q (or possibly at x=q for extra clarity). \$\endgroup\$ – Peter Taylor Aug 17 '16 at 22:13
  • \$\begingroup\$ Have thought about it some more. It seems to me that you're trying to be overly clear, in the sense that I think you're trying to distinguish the element 2 of GF(3) from the element 2 of . Non-mathematicians are just going to get confused, and mathematicians are used to using the notation which makes sense and only distinguishing the elements of the different fields when it's really important. I propose the following for the first paragraph (with a footnote at the bottom of the question): \$\endgroup\$ – Peter Taylor Aug 18 '16 at 7:46
  • \$\begingroup\$ The finite field GF(q) of prime order q can be thought of as the integers {0,1,...,q-1} with addition and multiplication modulo q.<sup>[1]</sup> So a polynomial p over the field GF(q) is also a polynomial over the integers. If we evaluate p(q) over the integers, we are performing a base conversion of the coefficients of p in base q, and this gives a bijection between polynomials over GF(q) and the nonnegative integers. \$\endgroup\$ – Peter Taylor Aug 18 '16 at 7:46
  • \$\begingroup\$ <sup>[1]</sup> NB There are finite fields of prime power order GF(q^a), a > 1, but they don't have the same multiplication structure as the integers modulo q^a. \$\endgroup\$ – Peter Taylor Aug 18 '16 at 7:47
0
\$\begingroup\$

Simulate Bibliomancy

In this challenge, you must take input as a string, and output a random word. Please note that you cannot simply take a random number and take the item of the list at that index: You will be simulating pages.

Also note that rather than your program picking from the page with eyes closed (which would bias towards larger words), it will generate a random number, and pick the word corresponding to that number

Pages will be some amount characters long, according to input (sandbox: I need help with how pages are distinct (are they assumed to be separate, or do pages need to have truncated length if a word is too long)). Every page has an equal chance of being picked (assume the PRNG is even), and every word on the page as an equal chance of being picked. In this way, a word from a grandiloquent page, with fewer words, is more likely to be chosen than a word from a page with many short words, and all the words on a page have an equal chance of being chosen. The sum of the chances of picking any word from one page is equal to the sum of the chances of picking any word from another page.

, this is that


Of course, this still needs clarification. Halp sandbox

\$\endgroup\$
  • \$\begingroup\$ So the challenge is: Given a string describing the text of a book and an int describing the number of pages, divide the text into pages and pick a random word from a random page? \$\endgroup\$ – Emigna Aug 19 '16 at 8:10
  • \$\begingroup\$ Yeah, that probably is a better explanation than mine \$\endgroup\$ – Destructible Lemon Aug 19 '16 at 8:44
  • \$\begingroup\$ The difficulty of the challenge will be decides by how you decide that words which end up in the middle of a page split should be handled. Max chars per page would be another way of doing it as well. Would also change difficulty. \$\endgroup\$ – Emigna Aug 19 '16 at 9:02
0
\$\begingroup\$

The grand golfed double radiation-hardened quine

Yep. It's quite a mouthful.

  • Double radiation-hardened - removing any two characters still results in a valid quine.
  • Quine - a program that outputs itself

Rules

  • No reading from a file or from the web - that's cheating!
  • Standard loopholes apply.
  • File must be at least two characters long.

This is so the shortest answer in bytes wins.

I've seen singly radiation hardened quines before. Now it's your job to make doubly radiation hardened ones.


Please constructively criticize this challenge.

\$\endgroup\$
  • \$\begingroup\$ This is a duplicate; this challenge is about generalized radiation-hardened quines, and there's already one that can survive three removals there. \$\endgroup\$ – user62131 Dec 18 '16 at 8:14
0
\$\begingroup\$

Time-Quine Time!

Your task is to write a quine (I know, I know, old stuff. But bear with me for a moment) which waits for a certain amount of time after the start of its execution, then prints its own source-code.

Rules:

  • Standard Loopholes apply
  • Your program must always halt for the same amount of time before printing its source code (System independent)

Input

  • Your program should take no input

Output

  • The programs exact source code (After the wait)

Scoring:

  • This is code-golf, so shortest code wins, BUT:
  • The time your program waits before printing is also taken into account. SO:
  • Your score is equal to length of code (in bytes) / log(base 10)(time in seconds of wait)
  • Code golf, so shortest code wins

P.S.: Please indicate in your answer how long your code will wait for


All feedback is appreciated

\$\endgroup\$
  • \$\begingroup\$ Does a solution have to call a sleep() function or can it make some calculations (that would take a different amount of time on different machines)? \$\endgroup\$ – KarlKastor Aug 19 '16 at 17:53
  • \$\begingroup\$ The time it takes should always be the same and system-independent, so a sleep() call or similar would probably be the only way to do it. \$\endgroup\$ – Theo Aug 19 '16 at 17:54
  • \$\begingroup\$ Why is the wait duration relevant for scoring? Is this just some weird handcapping mechanism to favour languages with a sleepNanos method? \$\endgroup\$ – Peter Taylor Aug 19 '16 at 18:22
  • \$\begingroup\$ @PeterTaylor Should have been divided by. Fixed now. It's supposed to favor longer wait times. \$\endgroup\$ – Theo Aug 19 '16 at 18:37
  • \$\begingroup\$ Then I can get my score as low as I want by just adding more 9s to the wait time, because the numerator increases linearly and the denominator increases geometrically. \$\endgroup\$ – Peter Taylor Aug 19 '16 at 19:35
  • \$\begingroup\$ @PeterTaylor True. Any suggestions for making the denominator increase less than the numerator? \$\endgroup\$ – Theo Aug 19 '16 at 19:40
  • 1
    \$\begingroup\$ I don't think there is any fix, and I don't think it's interesting enough to be worth trying to fix anyway. \$\endgroup\$ – Peter Taylor Aug 19 '16 at 20:18
0
\$\begingroup\$

Print this text in as few bytes as you can

**********
****  ****
***    ***
**      **
*        *
*        *
**      **
***    ***
****  ****
**********

\$\endgroup\$
  • 1
    \$\begingroup\$ Seems boring but you can make it more interesting by having to generate the pattern in size n given n as input \$\endgroup\$ – Downgoat Aug 19 '16 at 23:16
  • 4
    \$\begingroup\$ I think fixed-output ASCII arts are fine, but I'd scale this up a bit because it might be hard to beat hardcodes or partial hardcodes in verbose languages. I also suggest doing a thorough dupe check. \$\endgroup\$ – xnor Aug 19 '16 at 23:17
  • 2
    \$\begingroup\$ IMO it's a dupe of this. \$\endgroup\$ – Peter Taylor Aug 20 '16 at 17:08
  • \$\begingroup\$ Somehow partial duplicate of Print an arch of ascending / descending numbers. \$\endgroup\$ – manatwork Aug 23 '16 at 10:53
0
\$\begingroup\$

Play the centipede game

(please note that I need to learn how to make a controller)

In this challenge, you must create a bot which plays the centipede game.

In the centipede game, there are two players, and two piles of coins. One pile is 1/4 the size of the other. Each turn, a player may choose to either: a) take the bigger pile of coins for himself, and push the smaller pile of coins over to the other player, or b) push both piles of coins to the other player. When the coins are pushed to the other player, the size of each of the pile of coins is doubled (in this way, the smaller pile increases to the current size of the big pile after two pushes).

In the original centipede game, there were 100 rounds (hence the name). However, in this game, there will be a random number of rounds. If the game ends without anyone defecting, the big pile will be evenly split between the bots.

The game is over when someone takes the pile instead of pushing it over, or the random amount of rounds are elapsed

I'm currently not entirely sure how to score it, but I know that a bot definitely cannot benefit from deliberately messing up the opponent (as in, it can't try to drag another players score down with it, even if that wouldn't be effective), other than the score it gains. something like Average score-(average score of games by other bots that weren't against the bot being scored), if that scoring method is not the inverse of what I'm trying to accomplish, but something formatted like that

\$\endgroup\$
  • \$\begingroup\$ It seems to me that there are two key factors which affect the analysis: do I know how many (half-)turns have already passed? And do I know how many (half-)turns are still to come? If the answer to the second is no, you should at least state the probability distribution. (We can extract it anyway from the controller, but it shouldn't be necessary to reverse engineer key details from the controller). \$\endgroup\$ – Peter Taylor Aug 22 '16 at 10:32
0
\$\begingroup\$

Square pegs in round holes

Does a square peg fit through a round hole? Let's find out ...

Input

  • Two 3-tuples, describing a circle and a square on the Cartesian coordinate plane.
  • They're represented here by the form (x, y, r) and (X, Y, S).
  • For both tuples, x and y are integers representing the center of the corresponding shape.
  • The r and S will only be positive integers numbers, with r representative of the radius of the circular hole, while S is the length of the side of the square.
  • The square is oriented parallel to the x and y axes -- i.e., the left and right sides of the square parallel the y axis, and the top and bottom sides of the square parallel the x axis.

(Meta: is this sufficient to describe the shapes?)

Output

  • A truthy/falsey value, written to STDOUT or returned, indicating whether the square peg will fit through the round hole.
  • The square can only fit through the round hole if the entirety of the square is completely enclosed in the circle -- no points of the square can intersect or lay outside the circle.
  • Both objects are fixed at their corresponding centers (no rotating or translating about the origin allowed).
  • Precision within usual 32-bit floating point is sufficient.

Rules

  • Either a full program or a function are acceptable.
  • The input numbers can be taken via any suitable format.
  • Standard loopholes are forbidden.
  • This is so all usual golfing rules apply, and the shortest code (in bytes) wins.

Examples

(x, y, r) (X, Y, S) -> result  # explanation
(1, 1, 1) (0, 0, 1) -> false   # square is offset from circle
(1, 1, 1) (1, 1, 1) -> true    # square easily fits in the circle
(1, 1, 1) (1, 1, 2) -> false   # some of the square is outside the circle
\$\endgroup\$
  • \$\begingroup\$ 1. Why floating point? It isn't necessary, and it excludes a lot of languages. 2. How can the result be ambiguous? \$\endgroup\$ – Peter Taylor Aug 20 '16 at 17:16
  • \$\begingroup\$ Elaboration: what this boils down to is: given (X, Y, S) and (x, y, r), check for i and j in {0, 1} whether (x - X - S*i)^2 + (y - Y - S*j)^2 < r^2. There's nothing there which can't be done in integers. An answer in (to pick a language with compile-time typing) Java which used floating point could be converted to an answer which uses integers just by changing some types and (if doing input from stdin) switching the parse method. Moreover, every test case which uses non-integer values can be converted to a test case which uses (potentially large) integers by simple scaling. \$\endgroup\$ – Peter Taylor Aug 21 '16 at 17:06
  • \$\begingroup\$ On the other point, I don't think "ambiguous" is the correct word for the situation you describe with rounding error. If input is in 32-bit floats then I think that promotion to 64-bit floats would be sufficient to guarantee a correct result. (If not then an 80-bit float would definitely be sufficient). In order to have a clear spec, I think you should really define the permitted error - although I note that it can only really be an issue with corners of the square which are very nearly axis-aligned with the centre of the circle and very near its edge. \$\endgroup\$ – Peter Taylor Aug 21 '16 at 17:12
  • \$\begingroup\$ @PeterTaylor Thanks for the detailed explanation -- you solved the problem in a different method than I had (briefly) sketched out, hence why I was hung up on floating point requirements. \$\endgroup\$ – AdmBorkBork Aug 22 '16 at 16:38
0
\$\begingroup\$

What number is this in the lowest possible base?

The challenge "What base is this number in" has an obvious extension:

Given a string that represents a number in an unknown base, determine the lowest possible base that number might be in, and taking the number in that base, output its base-10 representation. The string will only contain 0-9, a-z. If you like, you may choose to take uppercase letters instead of lowercase, but please specify this.

So, for example, if the input string is "01234", then the lowest possible base it could be a number in is 5. And in base-5, it represents:

01234_5 = 0 × 5^4 + 1 × 5^3 + 2 × 5^2 + 3 × 5^1 + 4 × 5^0 = (125 + 50 + 15 + 4)_10 = 194_10

So your program should output "194".

Your code must also work for base-1, aka "unary", where a number is represented by a string of zeros and its value is the number of digits. For example, 00000_1 = 5_10.

You can expect valid output to be anywhere from 0 to max_int.

You may take input and provide output in any reasonable format. Base-conversion built-ins are allowed (Sandbox q: Should there maybe be a bonus for not using them?), shortest answer in bytes is the winner!

Sample results:

    Input  | Base | Output
     1001  | 2    | 9
     34f9  | 16   | 13561
  0000000  | 1    | 7
  0000001  | 2    | 1
 codegolf  | 25   | 79234249915

Super-long example:

Input: 0123456789abcefghijklmnopqrstuvwxyz
Base: 36
Output (spaces for legibility, not required in actual program): 86 846 823 611 197 163 108 337 531 226 495 015 298 096 208 677 436 155

This output is roughly 180 bits, or 22.5 bytes, so may be out of range, but if your program can manage it then well done!

You may want to use baseconvert.com to help check your results.

\$\endgroup\$
  • \$\begingroup\$ I really don't get how 0000000 is 7 in base 1. \$\endgroup\$ – Dennis Aug 23 '16 at 1:59
  • \$\begingroup\$ In unary, rather than doing proper base calculations, you use each digit as a tally. So you just count how many 0s there are. Technically, you'd normally use 1111111 with a subscript 1, but since in this challenge 1111111 would be read as a binary number, I'm using the alternative definition. \$\endgroup\$ – ConMan Aug 23 '16 at 4:00
  • 1
    \$\begingroup\$ That's rather odd. Unary is a bijective numeration, so it doesn't even have zeroes. Personally, I'd just stike 1 from the possible bases. \$\endgroup\$ – Dennis Aug 23 '16 at 4:02
  • \$\begingroup\$ @Dennis, I think the point of including unary is that it's the only thing which stops the question being an exact duplicate. As it is, I think it's a close enough duplicate to close. \$\endgroup\$ – Peter Taylor Aug 23 '16 at 10:28
  • 1
    \$\begingroup\$ I believe this is a duplicate of codegolf.stackexchange.com/questions/48952/… \$\endgroup\$ – DJMcMayhem Aug 23 '16 at 16:50
  • \$\begingroup\$ I searched for lowest base, and not minimum base. That's my fault and I'm fine with closing. \$\endgroup\$ – ConMan Aug 23 '16 at 23:13
0
\$\begingroup\$

How can I get To a RepDigit Rep?

Heavily inspired by this challenge

In the referenced challenge, Repdigits are defined as numbers composed of repeating single digits (1, 111, 88, 99999, etc). In this challenge, we will calculate the minimum number of Stack Exchange Q/A votes it takes to take a reputation to a repdigit.

A vote can either be:

  • Question upvote (+5)
  • Answer upvote (+10)
  • Question/Answer downvote (-2)

Input: A single positive integer which represents a Stack Exchange reputation

Output: The minimum number of votes required to reach the nearest repdigit

Rules:

  • Answer may be either program or function
  • Input may be user input, read from a file, or function argument
  • Output may have trialing spaces/new lines and should be printed/displayed to STDOUT or nearest equivalent. Alternatively, output may be the return value of a function
  • Standard loopholes apply
  • Answers should work theoretically for infinite reputation, however for practicality, answers only need to work up to 889,107 reputation (Jon Skeet's SO rep at time of posting)

Test Cases:

Reputation: 1   =>  Votes: 0 (input is already a repdigit)
Reputation: 10  =>  Votes: 1 (one downvote will result in 8 rep)
Reputation: 500 =>  Votes: 6 (5 answer upvotes and 1 question upvote resulting in 555 rep)

This is codegolf, shortest code in bytes wins

\$\endgroup\$
  • \$\begingroup\$ What is the largest and smallest possible inputs as rep. \$\endgroup\$ – Rohan Jhunjhunwala Aug 25 '16 at 17:54
  • \$\begingroup\$ Minimum of 1, maximum of 889,109 \$\endgroup\$ – wnnmaw Aug 25 '16 at 19:11
  • \$\begingroup\$ Totally irrelevant but just out of curiosity: Will the figure shown for Jon Skeet's rep be updated with the current figure when this gets posted to main? \$\endgroup\$ – trichoplax Aug 27 '16 at 18:27
  • 1
    \$\begingroup\$ @trichoplax, yeah, of course, its attention to detail that makes a good challenge! \$\endgroup\$ – wnnmaw Aug 28 '16 at 13:21
0
\$\begingroup\$

Strict Music Interval Describer

Given two notes, you might think you can combine Print the sizes of intervals inside of a piece of music to give you the number of semitones with Music Interval Solver to give you the name of the interval between them. Unfortunately doing this loses information. You might notice from the Music Interval Solver that different intervals can have the same number of semitones. In order to know which interval we should use, we need to refer back to the original note names.

The base name of an interval can always be determined from the inclusive number of note names, excluding accidentals, from the first note to the second. Note that intervals wrap after the octave, so that G# to C# is a fourth (G, A, B, C). For this question the octave numbers are not provided so you should assume that the interval will always be an ascending interval between a second and an octave.

To avoid having to refer to the linked questions, I will remind you that the notes themselves have differing numbers of semitones between them; E & F and B & C have one while the others have two. G to C is therefore 2 + 2 + 1 = 5 semitones.

You also need to take into account the accidentals; we'll use # and b for simplicity. They each alter the interval by 1 semitone; # increases it if used on the second note while b increases it if used on the first note. Naturally if both notes have the same accidental then they will cancel out.

An interval also has a modifier. My fourth above was in fact a perfect fourth, because the number of semitones was 5; the other possible perfect interval is a perfect fifth, which is 7 semitones. You can choose whether to use octave or perfect octave for 12 semitones.

Seconds, thirds, sixths and sevenths have minor and major intervals. The major intervals are 2, 4, 9 and 11 semitones; the minor intervals have one fewer.

Unlike the Music Interval Solver, if your interval does not match any of the intervals so far, you cannot simply change to a different base interval. Instead, you must augment or diminish your interval. For the purposes of this question any interval smaller than a minor or perfect interval is a diminished interval, and any interval larger than a major or perfect interval is an augmented interval.

Test cases:

Eb F# - augmented second
C# Eb - diminished third
G# C# - perfect fourth
F B - augmented fourth
B F - diminished fifth
Db B# - augmented sixth
A# Gb - diminished seventh
C# C - diminished octave

Input/output can be in any reasonable format (e.g. one string with a space separator, an array of two strings). This is , so the shortest code wins.

\$\endgroup\$
  • \$\begingroup\$ 1. The first sentence seems backwards to me: surely the issue you're disagreeing with is the input, not the output, so why "providing"? 2. If I understand this correctly, you want to take two notes as input, map to the separation between them, and then pass that through to the earlier question. In other words, it seems to be codegolf.stackexchange.com/q/5410/194 + codegolf.stackexchange.com/q/76120/194 . I think that makes it a dupe. \$\endgroup\$ – Peter Taylor Aug 25 '16 at 13:40
  • \$\begingroup\$ No, the note names are highly relevant. It is wrong to describe an interval of F to B as a diminished fifth or B to F as an augmented fourth. \$\endgroup\$ – Neil Aug 25 '16 at 15:04
  • \$\begingroup\$ When you say, "No," with what precisely are you disagreeing? \$\endgroup\$ – Peter Taylor Aug 25 '16 at 15:15
  • \$\begingroup\$ I'm disagreeing with your comment part 2. \$\endgroup\$ – Neil Aug 25 '16 at 15:22
  • \$\begingroup\$ So are you saying that 5410 is badly specified? Or something else? \$\endgroup\$ – Peter Taylor Aug 25 '16 at 15:45
  • \$\begingroup\$ It only required you to output a possible name of the interval, given that you had incomplete information. Maybe it was deliberately specified like that because it allowed simpler input requirements. \$\endgroup\$ – Neil Aug 25 '16 at 16:32
  • \$\begingroup\$ I think we're talking at cross-purposes. 5410 (linked in my first comment) is: given two notes, how many semitones is it from the first to the second. Then 76120, which you also linked in the question, is: given the distance in semitones, what's the name of the interval. The combination of the two seems to me to be: given two notes, what is the name of the interval between them. \$\endgroup\$ – Peter Taylor Aug 25 '16 at 16:42
  • \$\begingroup\$ No, because you lose data; 5410 will output 6 semitones for both F to B and B to F, and then 76120 doesn't know whether that's an augmented fourth or a diminished fifth. \$\endgroup\$ – Neil Aug 25 '16 at 18:54
  • \$\begingroup\$ Having read this question several times, neither do I, so maybe if you improve the specification the difference will become apparent. \$\endgroup\$ – Peter Taylor Aug 25 '16 at 21:53
  • \$\begingroup\$ I don't know a clearer way of putting it than the inclusive number of note names. F to B is a fourth because there are four letters F, G, A, B. B to F is a fifth because there are five letters B, C, D, E, f. \$\endgroup\$ – Neil Aug 25 '16 at 21:57
  • \$\begingroup\$ I think what Neil's getting at is that modified intervals should be expressed relative to the note with the same letter name as the second input in the major scale corresponding to the first input? But it's not specified what should happen if two or three sharps/flats need to be applied to get from the scale note to the second input. Also, two of the test cases are inaccurate: C#-Eb is a second, and Db-B# is a major seventh. \$\endgroup\$ – feersum Aug 25 '16 at 23:36
  • \$\begingroup\$ @feersum C to E is three notes, not two, and D to B is six notes, not seven. \$\endgroup\$ – Neil Aug 26 '16 at 7:33
  • \$\begingroup\$ @feersum No, that's a minor third. \$\endgroup\$ – Neil Aug 26 '16 at 7:38
  • \$\begingroup\$ All right, I see that diminished third is actually a standard term. But it seems to conflict with the rule saying If your interval does not match any of the ones so far... since the interval does match one of the ones listed above. \$\endgroup\$ – feersum Aug 26 '16 at 7:49
  • \$\begingroup\$ @feersum I've rephrased my question a bit, does that help? \$\endgroup\$ – Neil Aug 26 '16 at 8:37
0
\$\begingroup\$

Limit a table

(this is in minimal form, and is in rough sandbox stage. refrain from voting at this stage. I will flesh it out at a later point in time.)

Given a CSV file containing two columns, and an integer N, format the table into multiple rows such that each column contains at most N rows, excluding the header. Like this, for N = 3:

Foo,Bar
hello,world
lorem,ipsum
doler,illum
asdf,fdasfa
qwerty,dvorak
tildes,graves
stuff,hello
limit,ipsum
a,b

Becomes:

Foo,Bar,Foo,Bar,Foo,Bar
hello,world,asdf,fdasfa,stuff,hello
lorem,ipsum,qwerty,dvorak,limit,ipsum
doler,illum,tildes,graves,a,b
\$\endgroup\$
  • \$\begingroup\$ I think I understand how the output is constructed from the input, but this is basically not explained in the challenge which makes it extremely unclear. \$\endgroup\$ – Fatalize Aug 29 '16 at 7:07
  • \$\begingroup\$ @Fatalize of course. "this is in minimal form, and is in rough sandbox stage." \$\endgroup\$ – Conor O'Brien Aug 29 '16 at 11:08
0
\$\begingroup\$

Tower of Hanoi Hamiltonian Cycle

Every tower of Hanoi has a unique Hamiltonian cycle of length 3ⁿ. The cycle for n=1 is simply 1| | , |1| , | |1 while for n=2 it is as follows:

12          move disc 1 from rod 1 to rod 2
2   1                 2          1        3
    1   2             1          2        3
        12            1          3        1
1       2             2          3        2
1   2                 1          1        2
    12                1          2        3
    2   1             2          2        1
2       1             1          3        1 - closes cycle

Your task is to write a program or function which, given a positive integer n, returns the Hamiltonian cycle for the Hanoi Graph of order n.

You can output the graph starting at any point and traversing it in either order. You can output the graph as a list of positions or a list of moves. It must be possible to loop back from the last line of your output to the first, but you don't have to repeat the position.

This is , so the shortest solution wins.

\$\endgroup\$
  • \$\begingroup\$ The cycle can be constructed as a trivial variant of solving the standard tower of Hanoi puzzle, making this a duplicate. \$\endgroup\$ – Peter Taylor Sep 3 '16 at 8:25
  • \$\begingroup\$ The standard solution is simply a straight line along the edge of the Hanoi graph, while the cycle is a fractal. How is that a trivial variant? \$\endgroup\$ – Neil Sep 3 '16 at 10:04
0
\$\begingroup\$

Warn me when charger is unplugged!

So, I've a Compaq Presario V6000 laptop. Two years ago, battery died because of overcharging; So I had to plug charger in order to work with. Without the charger plugged, it runs out of power after ~4 seconds. Unfortunately, today I found out that charger port is tighten because of intense use & charger gets unplugged after few minutes. Your task is to solve my problem by writing a full program which warns me about unplugged charger!

GOAL

  • Write a full program that opens an X windows or makes similar graphical drawing that warns me about unplugged charger with writing "WARNING" in a readable font with size 36 and in color red.

  • Your program must warn me in less than 2 seconds after being unplugged.

  • Information about my laptop is available HERE. It's running Slacko puppy 6.3.0 with JWM & other default programs.

Here's what I've in /dev directory :

adsp
agpgart
audio
audio1
autofs
bsg
btrfs-control
bus
cdrom
char
console
cpu_dma_latency
cuse
dac960_gam
dri
dsp
dsp1
dvd
fb0
fd
full
fuse
hidraw0
hpet
hwrng
input
kmsg
log
loop0
loop1
loop10
loop11
loop12
loop13
loop14
loop15
loop2
loop3
loop4
loop5
loop6
loop7
loop8
loop9
loop-control
mapper
mcelog
md0
mem
mixer
mixer1
mouse
mptctl
nbd0
nbd1
nbd10
nbd11
nbd12
nbd13
nbd14
nbd15
nbd2
nbd3
nbd4
nbd5
nbd6
nbd7
nbd8
nbd9
net
network_latency
network_throughput
null
port
ppp
psaux
ptmx
pts
ptya0
ptya1
ptya2
ptya3
ptya4
ptya5
ptya6
ptya7
ptya8
ptya9
ptyaa
ptyab
ptyac
ptyad
ptyae
ptyaf
ptyb0
ptyb1
ptyb2
ptyb3
ptyb4
ptyb5
ptyb6
ptyb7
ptyb8
ptyb9
ptyba
ptybb
ptybc
ptybd
ptybe
ptybf
ptyc0
ptyc1
ptyc2
ptyc3
ptyc4
ptyc5
ptyc6
ptyc7
ptyc8
ptyc9
ptyca
ptycb
ptycc
ptycd
ptyce
ptycf
ptyd0
ptyd1
ptyd2
ptyd3
ptyd4
ptyd5
ptyd6
ptyd7
ptyd8
ptyd9
ptyda
ptydb
ptydc
ptydd
ptyde
ptydf
ptye0
ptye1
ptye2
ptye3
ptye4
ptye5
ptye6
ptye7
ptye8
ptye9
ptyea
ptyeb
ptyec
ptyed
ptyee
ptyef
ptyp0
ptyp1
ptyp2
ptyp3
ptyp4
ptyp5
ptyp6
ptyp7
ptyp8
ptyp9
ptypa
ptypb
ptypc
ptypd
ptype
ptypf
ptyq0
ptyq1
ptyq2
ptyq3
ptyq4
ptyq5
ptyq6
ptyq7
ptyq8
ptyq9
ptyqa
ptyqb
ptyqc
ptyqd
ptyqe
ptyqf
ptyr0
ptyr1
ptyr2
ptyr3
ptyr4
ptyr5
ptyr6
ptyr7
ptyr8
ptyr9
ptyra
ptyrb
ptyrc
ptyrd
ptyre
ptyrf
ptys0
ptys1
ptys2
ptys3
ptys4
ptys5
ptys6
ptys7
ptys8
ptys9
ptysa
ptysb
ptysc
ptysd
ptyse
ptysf
ptyt0
ptyt1
ptyt2
ptyt3
ptyt4
ptyt5
ptyt6
ptyt7
ptyt8
ptyt9
ptyta
ptytb
ptytc
ptytd
ptyte
ptytf
ptyu0
ptyu1
ptyu2
ptyu3
ptyu4
ptyu5
ptyu6
ptyu7
ptyu8
ptyu9
ptyua
ptyub
ptyuc
ptyud
ptyue
ptyuf
ptyv0
ptyv1
ptyv2
ptyv3
ptyv4
ptyv5
ptyv6
ptyv7
ptyv8
ptyv9
ptyva
ptyvb
ptyvc
ptyvd
ptyve
ptyvf
ptyw0
ptyw1
ptyw2
ptyw3
ptyw4
ptyw5
ptyw6
ptyw7
ptyw8
ptyw9
ptywa
ptywb
ptywc
ptywd
ptywe
ptywf
ptyx0
ptyx1
ptyx2
ptyx3
ptyx4
ptyx5
ptyx6
ptyx7
ptyx8
ptyx9
ptyxa
ptyxb
ptyxc
ptyxd
ptyxe
ptyxf
ptyy0
ptyy1
ptyy2
ptyy3
ptyy4
ptyy5
ptyy6
ptyy7
ptyy8
ptyy9
ptyya
ptyyb
ptyyc
ptyyd
ptyye
ptyyf
ptyz0
ptyz1
ptyz2
ptyz3
ptyz4
ptyz5
ptyz6
ptyz7
ptyz8
ptyz9
ptyza
ptyzb
ptyzc
ptyzd
ptyze
ptyzf
ram0
ram1
ram10
ram11
ram12
ram13
ram14
ram15
ram2
ram3
ram4
ram5
ram6
ram7
ram8
ram9
random
rfkill
rtc0
sda
sda1
sda2
sequencer
sequencer2
shm
snd
sr0
stderr
stdin
stdout
tty
tty0
tty1
tty10
tty11
tty12
tty13
tty14
tty15
tty16
tty17
tty18
tty19
tty2
tty20
tty21
tty22
tty23
tty24
tty25
tty26
tty27
tty28
tty29
tty3
tty30
tty31
tty32
tty33
tty34
tty35
tty36
tty37
tty38
tty39
tty4
tty40
tty41
tty42
tty43
tty44
tty45
tty46
tty47
tty48
tty49
tty5
tty50
tty51
tty52
tty53
tty54
tty55
tty56
tty57
tty58
tty59
tty6
tty60
tty61
tty62
tty63
tty7
tty8
tty9
ttya0
ttya1
ttya2
ttya3
ttya4
ttya5
ttya6
ttya7
ttya8
ttya9
ttyaa
ttyab
ttyac
ttyad
ttyae
ttyaf
ttyb0
ttyb1
ttyb2
ttyb3
ttyb4
ttyb5
ttyb6
ttyb7
ttyb8
ttyb9
ttyba
ttybb
ttybc
ttybd
ttybe
ttybf
ttyc0
ttyc1
ttyc2
ttyc3
ttyc4
ttyc5
ttyc6
ttyc7
ttyc8
ttyc9
ttyca
ttycb
ttycc
ttycd
ttyce
ttycf
ttyd0
ttyd1
ttyd2
ttyd3
ttyd4
ttyd5
ttyd6
ttyd7
ttyd8
ttyd9
ttyda
ttydb
ttydc
ttydd
ttyde
ttydf
ttye0
ttye1
ttye2
ttye3
ttye4
ttye5
ttye6
ttye7
ttye8
ttye9
ttyea
ttyeb
ttyec
ttyed
ttyee
ttyef
ttyp0
ttyp1
ttyp2
ttyp3
ttyp4
ttyp5
ttyp6
ttyp7
ttyp8
ttyp9
ttypa
ttypb
ttypc
ttypd
ttype
ttypf
ttyq0
ttyq1
ttyq2
ttyq3
ttyq4
ttyq5
ttyq6
ttyq7
ttyq8
ttyq9
ttyqa
ttyqb
ttyqc
ttyqd
ttyqe
ttyqf
ttyr0
ttyr1
ttyr2
ttyr3
ttyr4
ttyr5
ttyr6
ttyr7
ttyr8
ttyr9
ttyra
ttyrb
ttyrc
ttyrd
ttyre
ttyrf
ttys0
ttyS0
ttys1
ttyS1
ttys2
ttyS2
ttys3
ttyS3
ttys4
ttys5
ttys6
ttys7
ttys8
ttys9
ttysa
ttysb
ttysc
ttysd
ttyse
ttysf
ttyt0
ttyt1
ttyt2
ttyt3
ttyt4
ttyt5
ttyt6
ttyt7
ttyt8
ttyt9
ttyta
ttytb
ttytc
ttytd
ttyte
ttytf
ttyu0
ttyu1
ttyu2
ttyu3
ttyu4
ttyu5
ttyu6
ttyu7
ttyu8
ttyu9
ttyua
ttyub
ttyuc
ttyud
ttyue
ttyuf
ttyv0
ttyv1
ttyv2
ttyv3
ttyv4
ttyv5
ttyv6
ttyv7
ttyv8
ttyv9
ttyva
ttyvb
ttyvc
ttyvd
ttyve
ttyvf
ttyw0
ttyw1
ttyw2
ttyw3
ttyw4
ttyw5
ttyw6
ttyw7
ttyw8
ttyw9
ttywa
ttywb
ttywc
ttywd
ttywe
ttywf
ttyx0
ttyx1
ttyx2
ttyx3
ttyx4
ttyx5
ttyx6
ttyx7
ttyx8
ttyx9
ttyxa
ttyxb
ttyxc
ttyxd
ttyxe
ttyxf
ttyy0
ttyy1
ttyy2
ttyy3
ttyy4
ttyy5
ttyy6
ttyy7
ttyy8
ttyy9
ttyya
ttyyb
ttyyc
ttyyd
ttyye
ttyyf
ttyz0
ttyz1
ttyz2
ttyz3
ttyz4
ttyz5
ttyz6
ttyz7
ttyz8
ttyz9
ttyza
ttyzb
ttyzc
ttyzd
ttyze
ttyzf
uhid
uinput
urandom
vcs
vcs1
vcs2
vcs3
vcs4
vcs5
vcsa
vcsa1
vcsa2
vcsa3
vcsa4
vcsa5
vga_arbiter
vhost-net
zero

Here's what I've in /etc directory

acpi                      hostname               pavrecord
adjtime                   hosts                  pcmcia
asound.state              hosts.allow            pkcs11
at-spi2                   hosts.deny             ppp
bash_completion.d         init.d                 precord
belocs                    inittab                printcap
ca-certificates           inputrc                profile
ca-certificates.conf      issue                  profile.d
ca-certificates.conf.new  jwm-2.3.xslt           protocols
cdburnerdevice            kde                    Puppybackgroundpicture
clock                     keymap                 radiusclient
codepage                  keymap_previous        ramdiskfssize
cron.daily                lazarus                ramdisksize
cups                      ld.so.cache            rc.d
dbus-1                    ld.so.conf             rc_keymaps
default                   ld.so.conf.d           rc_maps.cfg
desktop_icon_theme        libnl                  README.txt
dhcpcd.conf               localtime              request-key.conf
dhcpcd.conf.new           localtime-copied-from  request-key.d
dhcpcd.duid               logrotate.d            resolutionfix
dhcpcd_state_notify       lvm                    resolv.conf
dhcpcd_state_notify.bak   lynx.cfg               rpc
dict.conf                 lynx.lss               samba
dictd.conf                mailcap                sane.d
DISTRO_SPECS              mc                     securetelnetrc
drirc                     mime.types             services
esd.conf                  misc                   shadow
esd.conf.new              mke2fs.conf            shadow-
eventmanager              mke2fs.conf.new        shells
fb.modes                  modprobe.d             simple_network_setup
fdprm                     modules                slsh.rc
file                      modules.conf           ssl
floppy                    mousebuttons           sudo.conf
fltk                      mousedevice            sudoers
fontmap                   mtab                   sudoers.d
fonts                     my.cnf                 system.jwmrc
foomatic                  my.cnf.d               udev
fpc.cfg                   mysqlaccess.conf       uniconf.conf
fppkg                     nanorc                 usb_modeswitch.conf
fppkg.cfg                 nanorc.new             usb_modeswitch.d
frisbee                   NETWORKING             vga
fstab                     networkmodules         wcpufreqdriver
fstab.bak                 networks               wgetrc
gamin                     network-wizard         windowmanager
gconf                     nscd.conf              wpa_supplicant.conf
gftp                      nscd.conf.new          wpa_supplicant.conf.new
group                     nsswitch.conf          wvdial.conf
group-                    oldmousedevice         wvdial_options
gshadow                   openldap               X11
gshadow-                  os-release             xdg
gtk-2.0                   pam.d                  xextraoptions
gtk-3.0                   pango                  xorgoverrides
hiawatha                  passwd
host.conf                 passwd-
  • Your program must not hurt my friend in any way

This is a . Shortest codes win!

\$\endgroup\$
  • \$\begingroup\$ This is an interesting one. However, the obvious problem is the fact that is it must be always running as a process, so an interpreted programming language will have problems, am I right? \$\endgroup\$ – Andreï Kostyrka Sep 3 '16 at 1:14
  • \$\begingroup\$ To other users: I think that the amount of information dumped into the the code areas could be greatly reduced by omitting such irrelevant things as sudoers, for example. Another think is making this challenge “do X for me”, maybe by reformulating the task. \$\endgroup\$ – Andreï Kostyrka Sep 3 '16 at 1:16
  • \$\begingroup\$ Oh, and how are we supposed to test our code if we do not have this notebook model? Maybe this challenge should be more general? \$\endgroup\$ – Andreï Kostyrka Sep 3 '16 at 1:17
0
\$\begingroup\$

Origami in One Dimension

In this restricted version of origami, the artist begins with an unfolded strip of paper n segments long, the segments labeled from 0 on the left up through n - 1 on the right. For instance, if n were 7, the unfolded strip of paper would look like this:

| 0 | 1 | 2 | 3 | 4 | 5 | 6 |

Then the artist repeatedly makes "mountain" folds, each time tucking the right side under the left, based on a sequence of crease locations S. These locations are given as integer distances from the paper's left edge.

For example, consider the sequence [3, 3, 0, 3]. According to it, the first crease in the paper above should be made three units from the left edge, so segments 3 through 6, to the right of the crease, would get tucked beneath 0 through 2 to the crease's left:

    | 0 | 1 | 2 \
| 6 | 5 | 4 | 3 /

The second crease is to be three units from the new left edge, so that fold would tuck the 2 and 3 under everything else:

    | 0 | 1  \
| 6 | 5 | 4 \ |
        / 3 / |
        \ 2  /

The third crease should fall zero units from the left edge, meaning that the entire paper is to its right, and the whole thing gets flipped over:

 /  2 \
| / 3 /
| \ 4 | 5 | 6 |
 \  1 | 0 |

And finally, the fourth fold falls on the paper's right edge, flipping nothing.

Thus, the completed artwork, when viewed from above, would read [2, 5, 6].

Write a program or function that, given the nonnegative integer n and a sequence of crease locations S, returns the sequence of integers visible on the final folded paper as seen from above. You may assume that all of the elements of S are in-bounds, though creases are allowed to fall on edges as above. Some randomly generated sample inputs and outputs:

0,  []                       -> []
1,  [1]                      -> [0]
2,  [0]                      -> [1, 0]
2,  [1, 0, 1]                -> [1]
3,  [0, 2]                   -> [2, 1]
3,  [3, 2]                   -> [0, 1]
3,  [0, 1, 0, 2, 2, 2]       -> [1, 0]
4,  [1, 1]                   -> [1, 3]
4,  [2, 2]                   -> [0, 1]
4,  [4, 2, 2, 0]             -> [2, 3]
5,  [3, 2]                   -> [0, 1]
5,  [3, 0, 0]                -> [0, 1, 2]
5,  [5, 0, 1]                -> [0, 1, 2, 4]
6,  [2]                      -> [5, 4, 0, 1]
6,  [5, 0]                   -> [5, 3, 2, 1, 0]
6,  [6, 1, 1]                -> [1, 2, 3, 5]
6,  [0, 2, 4, 3, 1, 0, 2]    -> [1, 5]
7,  [6, 1, 2]                -> [1, 6, 4]
7,  [3, 3, 0, 3]             -> [2, 5, 6]
7,  [7, 2, 0, 0]             -> [6, 5, 4, 0, 1]
7,  [3, 0, 0, 1, 2]          -> [3, 4]
8,  [3, 1]                   -> [3, 4, 5, 7]
8,  [3, 2, 3]                -> [3, 7, 6]
9,  []                       -> [0, 1, 2, 3, 4, 5, 6, 7, 8]
9,  [2, 1]                   -> [2, 3, 4, 5, 6, 8]
9,  [5, 1]                   -> [5, 6, 7, 0]
9,  [8, 4, 2, 0, 0]          -> [0, 1]
10, [3, 2]                   -> [3, 4, 5, 9, 8]
10, [0, 5, 5]                -> [9, 8, 7, 6, 5]
10, [0, 3, 1, 5, 2, 0, 0, 0] -> [4, 3, 2]

Rules and scoring are as usual for .

Remaining Sandbox Questions

In addition to general feedback, I'd appreciate an input on:

  • Is the revised specification clear?
  • Is the barrier to getting started on this challenge low enough?
  • Is there sufficient room here for a variety of approaches?
\$\endgroup\$
  • 1
    \$\begingroup\$ Very neat challenge, but I think you should clarify some edge cases: 1) if the fold is done at 0, does that just rotate the entire paper 180 degrees? 2) Will the paper ever be folded onto other layers, e.g. at the end of your example, could there be a 1, and if so would the 2 go below the 0? 3) Will a fold ever affect multiple layers, e.g. 8, [4, 2] and if so are they folded individually or all together? I assume you've covered these in your test cases, but it would be great to see them in the worked example, so people don't have to reverse engineer these details from the test cases. \$\endgroup\$ – Martin Ender Aug 29 '16 at 7:59
  • \$\begingroup\$ As for tags, I'd probably drop sequence. It's usually used for OEIS-like integer sequences, and you seem to be using it to refer to lists, which is covered by array-manipulation. \$\endgroup\$ – Martin Ender Aug 29 '16 at 8:00
  • \$\begingroup\$ Revised per comments. \$\endgroup\$ – Edward Sep 2 '16 at 23:57
0
\$\begingroup\$

Simulate World's smallest universal Turing machine


Goal:

to implement world smallest automata which was proved (though, not strictly) to be able to simulate any other universal Turing machine, Wolfram's 2-state 3-symbol Turing machine & prove your language's Turing-completeness.

enter image description here

Specification:

{{1, 2} -> {1, 1, -1}, {1, 1} -> {1, 2, -1}, {1, 0} -> {2, 1, 1}, {2, 2} -> {1, 0, 1}, {2, 1} -> {2, 2, 1}, {2, 0} -> {1, 2, -1}}

where this means {state, color} -> {state, color, offset}. (Colors of cells on the tape are sometimes instead thought of as "symbols" written to the tape.) Source

"Word" description:

Think of this machine as an array processing function. This array has a pointer accessible by function. Every cell in this array can store an integer from 0 upto 2. Array is infinite from both sides & pointer is pointing to somewhere in the middle of this array. function itself has 2 modes. in each mode, it works different than other. Let's call these 2 modes "A" & "B".

if in state "A" :

  • if the value of the cell pointed by pointer is 0, change it to 1 & increase pointer & toggle state;

  • if the value of the cell pointed by pointer is 1, change it to 2 & decrease pointer;

  • if the value of the cell pointed by pointer is 2, change it to 1 & decrease pointer;

if in state "B" :

  • if the value of the cell pointed by pointer is 0, change it to 2 & decrease pointer & toggle state;
  • if the value of the cell pointed by pointer is 1, change it to 2 & increase pointer;
  • if the value of the cell pointed by pointer is 2, change it to 0 & increase pointer & toggle state;

(Increasing the pointer moves it to right.)

Your program's array must be at least (2^16+1) and when it goes out of boundary, pointer must come back from other side. Size of array must be either dynamic or odd (Which at first, pointer is pointing to middle element of array).

I/O format

Though there aren't strict rules about input & output. Your program must at least get number of iterations as an input & output current pointer address (an integer, 0 at first, negetive if pointer gets decremented to subzero) & value of pointed cell along with a seprator (e.g. space) at every iteration. Though this is the minimal requirement.

Winning criteria(s)

There aren't many restrictions about challenge itself. But for wining, you'll need to get other users' votes. You can try to make an optimized system, or simulate it in a strange language, or have an strange design. But you mustn't add anything extra to machine itself, and must be able to produce the exact state of pointer and tape in a particular iteration.

This is a . Answers with highest votes will win.

\$\endgroup\$
  • 1
    \$\begingroup\$ This looks like a "be creative" popcon, which should be avoided. Why popcon rather than an objective winning criterion? \$\endgroup\$ – Peter Taylor Sep 4 '16 at 7:31
0
\$\begingroup\$

The number 3 is cursed; avoid it

Inspired from this

It's well know that the number 3 may lead to weird bugs in a program. So your task is to write a program to remove every literal 3 (only the base 10 number; not a 3 in a string, a variable name, a longer number or with a different base) in a source code written in the language of your program by the floor of π.

But you can't have the character 3 anywhere in your source code.

You can't use a language without number literals.

Test cases (source language: Python)

print(3)
=>
import math
print(int(math.pi))
print("3 * 1 = %d" % 3)
=>
import math
print("3 * 1 = %d" % int(math.pi))
var1 = var2 = 33
var3 = 3 * var1 + var2 * 3
print("3 * %d + %d * 3 = %d" % var3)
=>
import math
var1 = var2 = 33
var3 = int(math.pi) * var1 + var2 * int(math.pi)
print("3 * %d + %d = %d" % var3)
print(0x3)
=>
print(0x3)

Since this is , the shortest answer in bytes win. Good luck!

\$\endgroup\$
  • \$\begingroup\$ So the empty brainfuck program wins? \$\endgroup\$ – Dennis Sep 3 '16 at 18:10
  • 5
    \$\begingroup\$ 1. There isn't a clear definition of esolang. Also, it makes no sense to disallow a huge number of programming languages, just because a small subset of them trivializes the problem. 2. What about 0x3, 0o3 or 0b11 in Python? Those are also numeric literals that represent 3. 3. What is the language in question doesn't have a built-in for Pi? 4. What counts as flooring? Python's int doesn't floor, although it happens to work that way for pi. \$\endgroup\$ – Dennis Sep 3 '16 at 19:18
  • \$\begingroup\$ Why is there a language restriction at all? \$\endgroup\$ – Beta Decay Sep 3 '16 at 20:20
  • \$\begingroup\$ @βετѧΛєҫαγ To prevent 0-byte brainfuck answer \$\endgroup\$ – TuxCrafting Sep 3 '16 at 20:21
  • \$\begingroup\$ Should the resulting program run/compile? For example, the Haskell code 3 + 1.0 works, but floor pi + 1.0 gives a type error. Can we add additional code to fix such things (-> fromInteger (floor pi) + 1.0)? \$\endgroup\$ – nimi Sep 3 '16 at 22:08
  • \$\begingroup\$ @nimi Yes you can \$\endgroup\$ – TuxCrafting Sep 3 '16 at 22:24
  • \$\begingroup\$ I guess, the resulting program should run/compile and do exactly the same as the original program (maybe you should note this explicitly). There are far more exceptions where a replacement will fail than in your list (not a string, not a variable name, etc). Examples are Basic's line numbers or Perl's format which has literal text without being a string. I doubt one can name them all. You can argue that not all languages are suited for this task, but then why make exceptions at all? \$\endgroup\$ – nimi Sep 4 '16 at 9:27
0
\$\begingroup\$

Output a confusion matrix

A confusion matrix is a pretty typical thing to see in a machine learning paper. It is a matrix where each cell contains the number of instances of the class of the row that were classified as the class of the column.

For example, if we have two classes A and B, and 4 instances [A, A] (meaning that instance is of class A and was classified as A), [A, B], [B, B] and [B, B], then the resulting confusion matrix would be:

  A B
A 1 1
B   2

TODO: more details about the format, what happens if the name of the classes have different lengths, etc. etc.

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

Output a number tent

tags:


Given an integer, output a number tent. (The number tent is just called as such.)

The input determines:

  • whether the tent is upside down (negative) or right way up (positive),
  • whether the entrance is on the left side (even) or the right side (odd), and
  • the size of the tent (abs(input/2) http://mathurl.com/hwkkw3f.png with integer division).

For input -4:
________
\  /   /
 \/___/

Assume that the input will never be 1, 0 or -1.

TODO Clarify.

Your code should be as short as possible.

\$\endgroup\$
  • 1
    \$\begingroup\$ Input of 1 should return an empty string (as should -1 and, of course, 0, although we should clarify that size is abs(input/2) with integer division). Tag suggestion: ascii-art \$\endgroup\$ – Jonathan Allan Sep 7 '16 at 18:18
0
\$\begingroup\$

Auto golf a string

Your objective is to make a program (written in a language of your choice) that takes arbitrary strings as input and outputs a program in a constant target language that, when run, prints that string. The original program does not have to be golfed, but the output programs should be in some way optimal or nearly optimal.

Voters are encouraged to keep the following points in mind when voting:

  1. How difficult is the target language to program in? Is it on par with languages such as Brainfuck and whitespace, or is it something trivial, like Python or Ruby?
  2. How efficient is the golfer? That is, how does it compare to any existent auto string golfers? And how does it compare to hand-golfing?

Meta

Okay, so this isn't our usual type of challenge, but I think this could really turn out well. However, I think this is underspecified as it is, and would appreciate feedback.

\$\endgroup\$
  • \$\begingroup\$ This may overlap with some other metagolfing questions... That will mean that any future kolmo meta-golfing qs will be dupes. \$\endgroup\$ – Beta Decay Sep 11 '16 at 20:00
  • \$\begingroup\$ @BetaDecay Yeah, but only in reference to strings \$\endgroup\$ – Conor O'Brien Sep 11 '16 at 21:06
  • \$\begingroup\$ This is a bad fit for a site with a 30000 character limit to answers. I would have to golf 12kB off my GolfScript-Kolmogorov program to fit it in an answer even without any explanation beyond the comments in the code. \$\endgroup\$ – Peter Taylor Sep 12 '16 at 11:12
  • \$\begingroup\$ @PeterTaylor that is certainly impressive. How substantial are the reductions? \$\endgroup\$ – Conor O'Brien Sep 12 '16 at 11:14
  • \$\begingroup\$ See e.g. codegolf.stackexchange.com/a/42400/194 , codegolf.stackexchange.com/a/11568/194 . Also related. \$\endgroup\$ – Peter Taylor Sep 12 '16 at 11:25
0
\$\begingroup\$

Balanced use of the alphabet

Write a program that counts from 1 to 100 and back down and ends by the sentence "I finished counting":

1, 2, 3, ... 97, 98, 99, 100, 99, 98, 97, ... 3, 2, 1, I finished counting

The output can be of any kind: array, comma separated, line separated, ...

In order to do that, your code reviewer (who has a wierd OCD) won't accept code that doesn't contain the same amount of each letters of the alphabet.

He also doesn't accept code with no letter at all because, you know... letters are cool.

Scoring

Your score will be codeLength * (mostRepresentedLetter / leastRepresentedLetter).

Example of scoring

(Bad) code:

for(int i=1;i<=100;i++){abcdefghijklmnopqrstuvwxyz();}

Length: 39
Most represented letter: i (5 times)
Least represented letter: a (once)
Score: 39 * 5 / 1 = 195

NOTE: if a letter is not at all present, divding something by zero will make an inifinite score. As this is , it is not something you want.

\$\endgroup\$
  • \$\begingroup\$ As written, what prevents folks from just putting any extraneous letters behind a comment? How would code that doesn't use ASCII, like APL or Jelly, be scored? \$\endgroup\$ – AdmBorkBork Sep 12 '16 at 13:40
  • \$\begingroup\$ Since the scoring isn't based solely on code length, maybe [code-challenge] is more suitable. \$\endgroup\$ – Geobits Sep 12 '16 at 20:07
0
\$\begingroup\$

Validate the traversals

Given inorder and preorder traversals of a binary tree, return a truthy or falsy value depending on whether they could be from the same tree.

Input can be strings of characters or arrays of characters or numbers, whatever is the most convenient. You can assume both inputs are the same length.

Examples:

inorder: A
preorder: A
result: true
example:
A

inorder: AB
preorder: AB
result: true
example:
A
 \
  B

inorder: AB
preorder: BA
result: true
example:
  B
 /
A

inorder: ABC
preorder: BCA
result: false
possible inorder trees:
    C   C   B   A   A
   /   /   / \   \   \
  B   A   A   C   C   B
 /     \         /     \
A       B       B       C
 CBA  CAB  BAC  ACB  ABC

This is , so the shortest solution wins.

\$\endgroup\$
  • \$\begingroup\$ The test cases should include some which repeat characters. \$\endgroup\$ – Peter Taylor Sep 12 '16 at 13:39
  • \$\begingroup\$ @PeterTaylor I'll have to make it clear in the question that the characters won't be repeated, as they're supposed to refer to different nodes in the tree. \$\endgroup\$ – Neil Sep 12 '16 at 13:54
0
\$\begingroup\$

Illuminati is Illuminati

This is a popularity contest inspired by a dedicated scratch programmer who made the program here: https://scratch.mit.edu/projects/117836320/. What the program does, is it takes in a string, and links the string to the Illuminati. This scratch program is especially popular because it demonstrates meta-satire on linking things to other things.

challenge

Your job is to more or less produce something of similar function and form to the one linked above.

Input:

Your program can take anything as an input, however, it has to be able to take something. My suggestion is a string.

Output:

Your program must output a series of links that make some sense, and eventually link your input to the illuminati.
The last output of your program must be some variation of [input] + " is Illuminati confirmed."

Scoring:

This is a popularity challenge. Your code isn't supposed to look great, or even execute well, so long as it has the most up votes. You must use a code that has a free compiler, and you must post your source code along with your program.

Tips and tricks:

This section will be updated, as people post suggestions in the comments.

  • The Illuminati music in the background could add some spiff to your program. you can download it here: http://www.aiomp3.com/download.php?mp3=hAAlDoAtV7Y
  • Unlike what the program listed above does, there are many more links to have done besides the number of letters an a string. try looking for anagrams, or similar words.
\$\endgroup\$
  • \$\begingroup\$ A question should ideally be self-contained. Without reading the external link, which could 404 tomorrow, I have no idea what you want the program to do. \$\endgroup\$ – Peter Taylor Sep 14 '16 at 10:03
  • \$\begingroup\$ @PeterTaylor the link will not 404. it's a permalink..... and you should know what I want it to do, I put in my post "What the program does, is it takes in a string, and links the string to the Illuminati." and "Your job is to more or less produce something of similar function and form to the one linked above." \$\endgroup\$ – user56309 Sep 14 '16 at 14:03
  • \$\begingroup\$ Seems humorous, give some examples. Also be more specific on what "links the string to the illuminati" means. \$\endgroup\$ – NonlinearFruit Sep 14 '16 at 14:43
0
\$\begingroup\$

Translate an SVG path

An SVG path consists of a number of components. Each component begins with a letter, which may be upper case for an absolute position or lower case for a relative position. The component then has a variable number of parameters. Parameters may be separated by commas or spaces.

For the purposes of this question, you will not need to support the H, L or A commands. This means that each component accepts an even number of parameters, and that alternate parameters refer to the X and Y coordinates.

Given an SVG path and X and Y displacements, please output the translated path.

Input and output should be in any reasonable format, as long as you are consistent, i.e. both coordinates should be in the same format, or they can use a Point type, while the output path should be in the same format as the input path.

Please avoid floating-point errors e.g. adding 0.1 to 0.1 and getting 0.199996 like Inkscape does when I asked it to do this.

Example:

Input:
6.4
6.4
M 6.4 12.8 L 19.2 25.6 l 6.4 -6.4 z

Output:
M 12.8 19.2 L 25.6 32 l 6.4 -6.4 z

This is , so the shortest program wins.

\$\endgroup\$
  • \$\begingroup\$ Does "exact arithmetic" mean use of floating point is forbidden? \$\endgroup\$ – trichoplax Sep 14 '16 at 14:05
  • \$\begingroup\$ @trichoplax By "exact arithmetic", I mean that you should ensure that you don't introduce floating-point accuracy errors in your output. The input list may be absolute or relative depending on whether the command letters are in upper or lower case. Relative coordinates do not need to be adjusted, of course. \$\endgroup\$ – Neil Sep 14 '16 at 14:53
  • \$\begingroup\$ It's worth including a summary of what commands need to be supported, and how each works. \$\endgroup\$ – trichoplax Sep 14 '16 at 15:14
  • \$\begingroup\$ Using floating point variables will introduce floating point errors for some values. Do you want to specify a minimum required accuracy, or do you want to insist on only number types that do not share the problems of floating point? \$\endgroup\$ – trichoplax Sep 14 '16 at 15:17
  • \$\begingroup\$ The numbers won't need huge amounts of accuracy, so I don't care how you represent the numbers internally, as long as the output contains no floating-point errors. \$\endgroup\$ – Neil Sep 14 '16 at 15:56
  • 1
    \$\begingroup\$ The problem is it's hard to avoid floating point errors without knowing what accuracy the inputs will have. \$\endgroup\$ – trichoplax Sep 14 '16 at 16:01
0
\$\begingroup\$

Pointfree Generator -- this is a draft.... --

What is this?

From Wikipedia's page:

Tacit programming, also called point-free style, is a programming paradigm 
in which function definitions do not identify the arguments
(or "points") on which they operate

Challenge

In this challenge, you will have to generate Haskell code in pointfree style. You can provide an answer in any language of your choice as long as it generates Haskell code.

The functions to generate will be polynomial function of multiple variables with integer coefficients like : f : x,y,z -> x^8*y*z + 3*y + 12

for example, the function f : x -> x² + 3x can be written in pointfree Haskell like this (3*)>>=flip((+).(^2)) or (+3)>>=(*)

Input

The input is a list of list of coefficients and exponants : For example, the f : x,y,z -> x^8*y*z + 3*y + 12 function will be defined as [[1,8,1,1],[3,0,1],[12]]

Output

Restrictions

Haskell function/operators allowed are the following : (+),(-),(*),(.),(^),flip,(=<<),(>>=)

Hints

Testing

Scoring

\$\endgroup\$

You must log in to answer this question.

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