527
\$\begingroup\$

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

Sandbox FAQ

Posting

To post to the sandbox, scroll to the bottom of this page and click "Answer This Question". Click "OK" when it asks if you really want to add another answer.

Write your challenge just as you would when actually posting it, though you can optionally add a title at the top. You may also add some notes about specific things you would like to clarify before posting it. Other users will help you improve your challenge by rating and discussing it.

When you think your challenge is ready for the public, go ahead and post it, and replace the post here with a link to the challenge and delete the sandbox post.

Discussion

The purpose of the sandbox is to give and receive feedback on posts. If you want to, feel free to give feedback to any posts you see here. Important things to comment about can include:

  • Parts of the challenge you found unclear
  • Comments addressing specific points mentioned in the proposal
  • Problems that could make the challenge uninteresting or unfit for the site

You don't need any qualifications to review sandbox posts. The target audience of most of these challenges is code golfers like you, so anything you find unclear will probably be unclear to others.

If you think one of your posts needs more feedback, but it's been ignored, you can ask for feedback in The Nineteenth Byte. It's not only allowed, but highly recommended!

It is recommended to leave your posts in the sandbox for at least several days, and until it receives upvotes and any feedback has been addressed.

Other

Search the sandbox / Browse your pending proposals

The sandbox works best if you sort posts by active.

To add an inline tag to a proposal use shortcut link syntax with a prefix: [tag:king-of-the-hill]. To search for posts with a certain tag, include the name in quotes: "king-of-the-hill".

Get the Sandbox Viewer to view the sandbox more easily!

\$\endgroup\$
0

3422 Answers 3422

1
96 97
98
99 100
115
0
\$\begingroup\$

Quineoid Triple Uniqueness Optimization


This is a variant of Quineoid Triple with the same requirements but different scoring.

Write three different programs such that when any one program is provided as input to one of the other two, you get the source of the remaining program as output. More explicitly, given programs \$A\$, \$B\$, and \$C\$, where \$f(g)\$ denotes the output obtained from inputting the text of program \$g\$ into program \$f\$, all of the following must hold:

  • \$ A(B) = C \$
  • \$ A(C) = B \$
  • \$ B(A) = C \$
  • \$ B(C) = A \$
  • \$ C(A) = B \$
  • \$ C(B) = A \$

Scoring

The goal is to have the three programs be as different as possible.

Your score is the sum of:

  • Number of unique bytes found in program \$A\$, but not \$B\$ or \$C\$
  • Number of unique bytes found in program \$B\$, but not \$A\$ or \$C\$
  • Number of unique bytes found in program \$C\$, but not \$A\$ or \$B\$

The theoretical maximum score is 256.

Additional Rules

  • Standard quine rules apply.
  • Each program can be in any language. Any number of them may share languages or each may use a different language.
  • Use any convenient IO format as long as each program uses a consistent convention.
    • Functions are allowed, as this counts as "any convenient IO".
  • The result of feeding a program its own source code is undefined
  • The result of feeding anything other than program text of either of the other two programs is undefined.
  • Byte encoding should be taken into account for languages with dedicated codepages.

SANDBOX: this is kind of -ish. Should I call it a bowling challenge?

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

Modular Chain Compression

A common trope in some kolmogorov-complexity challenges is to use repeated application of the modulo operator in order to compress large integers or string hashes into some range. For example, we can squash the numbers \$13,4,16\$ into \$0,1,2\$ by taking each number mod \$7\$ and then mod \$3\$. We call this sequence the modular chain \$7,3\$. In general, reducing a number \$k\$ by the modular chain \$n_1,n_2,\ldots,n_i\$ is equivalent to evaluating

$$(((k\ \text{mod}\ n_1)\ \text{mod}\ n_2)\ \ldots\ )\ \text{mod}\ n_i$$

In this challenge, you will be challenged to compress an arbitrary set of integers in this way. We say the length of the modular chain is the number of elements in the chain (not the number of bytes).

Input

You are given a fixed set of \$100\$ random 32-bit integers. Here they are:

2997344323
2062352342
1953414591
... (more on the actual post) ...

Output

Via whatever means necessary (brute-force, mathematics, etc) design a modular chain to compact these numbers into a small a range as possible. The modular chain must have a distinct output for each input number.

Scoring

In code-golf challenges, a modular chain is usually desirable if it achieves two things:

  • It compacts the input numbers or hashes into a small range.
  • It is short.

In this spirit, your score is the sum of the maximum output number of your modular chain and the length of your modular chain for the given input numbers.

Note an optimal modular chain could compress the input numbers into the range \$0 \ldots 99\$ with a single modulo operation, making the theoretical minimum score \$99 + 1 = 100\$.

The lowest scoring answer wins. You are encouraged (but not required) to post any code, mathematical background etc. that helped you design your modular chain.

\$\endgroup\$
2
  • \$\begingroup\$ Length in modulo operations or bytes? \$\endgroup\$ – user253751 Aug 25 '20 at 9:41
  • \$\begingroup\$ @user253751 The number of operations. Clarified. \$\endgroup\$ – Sisyphus Aug 25 '20 at 10:28
0
\$\begingroup\$

The fastest code to find a subset-sum

Given k sorted integers from low to high, output n permutations of those integers with sum as close as possible to m but not exceeding m. The output needs to be sorted from highest to lowest sum.

Input

k integers, n, m - as described above. All the k integers and m are positive 31-bit integers. Now since this is NP-complete problem, both k and n are small integers, 20 at most.

Output

One row for each premutation, with integers sorted from high to low. Also, the rows need to be sorted from highest to lowest sum

The fastest code wins

For the performance test, we will use the below input:

  • k = [67, 613, 2111, 2179, 2203, 2269, 3433, 3583, 4219, 5011]
  • m = 14,213
  • n = 10
\$\endgroup\$
1
  • 3
    \$\begingroup\$ 1) You might want to provide multiple test cases, so that the submissions don't use an algorithm that is fast only in some of them and very slow in the others. 2) For fair evaluation of speed, you need to run all submissions on your machine, so you need to provide some information about your machine's OS, RAM, CPU (also GPU if you want to allow using it). 3) Is the sum of all k integers guaranteed to be positive 31-bit integers? Otherwise we might face overflows during calculation. 4) I think you mean subsets instead of permutations. \$\endgroup\$ – Bubbler Aug 28 '20 at 4:42
0
\$\begingroup\$

[Unnamed]

This challenge is based on a somewhat unusual premise; the goal is to create a rectangular program (box) which is as large as possible, where each row and column will be a solution to a different challenge on this site.

For example, a 3×4 box might look like this:

abcd
 :-]
1234

As all solutions will be read from left to right or top to bottom, this would expand into seven programs:

abcd
 :-]
1234
a 1
b:2
c-3
d]4

For an answer to be valid, each one of these must be a valid solution to a different challenge on this site, in the same language. The box may be padded by whitespace, but must be rectangular (x groups of y bytes, separated by newlines). This is code bowling, so the longest answer in bytes wins.

Additional rules/clarifications:

  • Solutions cannot contain newlines (because otherwise they would be two separate rows/columns)
  • Yes, it will be possible to trivially get very high scores with some languages (like unary), but as with most challenges it's a competition within each language
  • Solutions do not have to be original, but ones copied from other answers should link to them
\$\endgroup\$
4
  • \$\begingroup\$ Unary won't be able to compete because the number of challenges on our site is lower than most Unary programs. It will be very hard to compete even in golfing languages, as the answerer will need to manually find the appropriate challenge to use. I don't really think a challenge that makes use of "all challenges on our site" is fun. \$\endgroup\$ – Bubbler Sep 10 '20 at 1:40
  • \$\begingroup\$ @Bubbler Yeah, now that I think about it I agree. I still like the concept, maybe there's something similar that might actually be fun. \$\endgroup\$ – Redwolf Programs Sep 10 '20 at 2:37
  • \$\begingroup\$ Maybe you could select a subset of challenges - something like what was done for this challenge? \$\endgroup\$ – Dingus Sep 17 '20 at 11:43
  • \$\begingroup\$ @Dingus Good idea! I'll see if I can fix a few other things, too. \$\endgroup\$ – Redwolf Programs Sep 17 '20 at 12:39
0
\$\begingroup\$

Targeted sum and difference of a sequence

You are given two things: a target integer(not necessarily positive) n, and a sorted list/array/etc. of non-negative integers a. (The list will have at least two elements). Your goal is to choose one element of a as your total, and then one by one, take elements of a, and either add or subtract them from your total. Print out all possible combinations(duplicates can be removed, but it is optional) of [a_1]±[a_2]±[a_3] or return them as a list/array/etc. .

In other words, find all solutions to n=[a_1]±[a_2]±[a_3]. The first element of a is not guaranteed to be a_1, nor is the second element guaranteed to be n_2.

Test cases:

n = 10, a = [1,2,3,4] :  10 = 1+2+3+4 and 2+1+3+4 ...
# The output should be 1+2+3+4(and 4+2+3+1, and every combination like that)
n = 1, a = [2,3]: 1 = 3-2, so 3-2. 
# (-2+3 wouldn't work, since it is strictly addition or subtraction of positive integers).
# -2 isn't a part of [2,3]. You should think of the steps as [a_1]±[a_2]±[a_3].
# n = -5, a = [0,5,1]. -5 = 0-5, and nothing else.
n=95, a = [50,50,5]. 95 = 50+50-5, 50-5+50. (A second 50+50-5 is optional)

Criteria: Shortest code wins

Meta:

Is this clear enough(and what should I do to make this more clear)? Also, has this been done before? Finally, should I remove the restriction on the first number being positive?

Thank You!

\$\endgroup\$
1
  • \$\begingroup\$ What do you mean by "The first element of a is not guaranteed to be a_1"? \$\endgroup\$ – Zgarb Sep 11 '20 at 7:01
0
\$\begingroup\$

A centered hexagonal number is a centered figurate number that represents a hexagon with a dot in the center and all other dots surrounding the center dot in a hexagonal lattice.

Illustration of initial terms:

                                 o o o o
                   o o o        o o o o o
         o o      o o o o      o o o o o o
   o    o o o    o o o o o    o o o o o o o
         o o      o o o o      o o o o o o
                   o o o        o o o o o
                                 o o o o

   1      7          19             37

Write a function that takes an integer \$n\$ and returns "Invalid" if \$n\$ is not a centered hexagonal number or its illustration as a multiline rectangular string otherwise.

Sample Output :-

hexLattice(1) ➞ " o "
// o

hexLattice(7) ➞ "  o o  \n o o o \n  o o  "
//  o o
// o o o
//  o o

hexLattice(19) ➞ "   o o o   \n  o o o o  \n o o o o o \n  o o o o  \n   o o o   "
//   o o o
//  o o o o
// o o o o o
//  o o o o
//   o o o

hexLattice(21) ➞ "Invalid"

Rules

Shortest Code Wins!

\$\endgroup\$
3
  • 4
    \$\begingroup\$ I like the challenge concept! Usually, we advise against input validation; that is, rather than outputting "Invalid", solutions should assume the input is valid, though if you do that this challenge is almost a duplicate and so I think in this case it could make for an interesting challenge to leave it in. \$\endgroup\$ – hyper-neutrino Mod Sep 23 '20 at 13:11
  • 4
    \$\begingroup\$ Another thing is usually we encourage flexible input/output formatting; in this case, in addition to a multiline string, I would also allow a list of strings or a matrix of characters as output, and rather than strictly outputting "Invalid", I would suggest allowing solutions to state any reasonable parameters for how they'll indicate invalid input. \$\endgroup\$ – hyper-neutrino Mod Sep 23 '20 at 13:13
  • \$\begingroup\$ Related-ish. There are several other hexagon related challenges but this was the only one I could find that required computing the centred hexagonal numbers. \$\endgroup\$ – FryAmTheEggman Sep 24 '20 at 18:58
0
\$\begingroup\$

Word Length-Sum Multiples

\$\endgroup\$
1
  • \$\begingroup\$ Now that this has been posted, I've edited it down to save space and I'd recommend you delete the proposal \$\endgroup\$ – caird coinheringaahing Sep 25 '20 at 0:15
0
\$\begingroup\$

Double Prime Words

\$\endgroup\$
5
  • 1
    \$\begingroup\$ tags would be decision-problem, code-golf, primes, I think? \$\endgroup\$ – Giuseppe Sep 8 '20 at 19:07
  • 1
    \$\begingroup\$ I think if and only if x is prime should be if and only if n is prime? \$\endgroup\$ – Giuseppe Sep 8 '20 at 19:08
  • \$\begingroup\$ Additional exampleː Is this word a double primeː Hello Worlds aardvark aalii Aani \$\endgroup\$ – Xwtek Sep 10 '20 at 12:36
  • \$\begingroup\$ @Xwtek Is that 4 separate examples, or 1 long example? \$\endgroup\$ – Sumner18 Sep 10 '20 at 15:09
  • \$\begingroup\$ Now that this has been posted, I've edited the post down to save space and I'd recommend you delete this proposal \$\endgroup\$ – caird coinheringaahing Sep 25 '20 at 0:19
0
\$\begingroup\$

\$d\times n\$ dimensional word matrices [WIP]

Given two positive integers \$n\$ and \$d\$, and a list of words \$a\$, produce a \$d\$-dimensional matrix \$m\$ with each dimension having length \$n\$, filled with letters, that contains the words from \$a\$ placed such that they form a directly adjacent contiguous path through the dimensions.

For example, given \$d = 1\$, \$n = 3\$ and \$a = \$['cat'] output one of:

cat

or

tac

Given \$d = 2\$, \$n = 3\$ and \$a = \$['cat', 'hat', 'mat'] output something similar to:

cat
hat
mat

Given \$d = 3\$, \$n = 3\$ and \$a = \$['low', 'complexity'] output something similar to:

coq
igw
typ

kmc
xeo
buf

kpr
dll
scm

or, if it's easier to visualise in an array structure:

[
  [
    ['c', 'o', 'q'],
    ['i', 'g', 'w'],
    ['t', 'y', 'p'],
  ],
  [
    ['k', 'm', 'c'],
    ['x', 'e', 'o'],
    ['b', 'u', 'f'],
  ],
  [
    ['k', 'p', 'r'],
    ['d', 'l', 'l'],
    ['s', 'c', 'm'],
  ],
]

Which contains low at nested indices \$m[2][1][2]\$, \$m[1][1][2]\$, \$m[0][1][2]\$ and complexity at \$m[0][0][0]\$, \$m[0][0][1]\$, \$m[1][0][1]\$, \$m[2][0][1]\$, \$m[2][1][1]\$, \$m[1][1][1]\$, \$m[1][1][0]\$, \$m[0][1][0]\$, \$m[0][2][0]\$, \$m[0][2][1]\$.

I'd like to add some more complicated examples beyond three dimensions here.

Test Cases

TODO

Rules

  • Unused spaces should be filled with randomly selected letters.
  • There will always be enough space in the dimensions provided to allow the words to be added without re-using letters.
  • There is no requirement to ensure the words don't also appear elsewhere in the grid, so for example if the filler letters happen to spell one of the provided words, that is acceptable.

Questions for meta

  • This seems fun to me, any thoughts?
  • Is it too easy/hard?
  • Any other tags that are relevant?
  • As a follow up, I'd like to have a nested matrix provided and have programs solve it - but that might be better as a fastest-code challenge - is this a reasonable precursor?
\$\endgroup\$
2
  • \$\begingroup\$ Is d^n large enough to contain all the words without sharing letters? \$\endgroup\$ – Bubbler Jul 23 '20 at 8:18
  • \$\begingroup\$ Yeah, you won't have to be concerned with that, I'll add that to the rules. \$\endgroup\$ – Dom Hastings Jul 23 '20 at 8:21
0
\$\begingroup\$

Find a 3-Language Polyglot

What I had in mind was that cops would create a polyglot with in 3 languages (languages A, B, and C). When run in A, the program would print the name of language B; when run in language B, the program would print the name of language C; and when run in C, it would print the name of language A.

Cops have to provide the names of these 3 languages, as well as their original polyglot's characters scrambled in no particular order. as well as a valid program in A that has the same behavior as the polyglot (prints the name of B). This program must be able to be created by deleting characters from the original polyglot, i.e., all the letters in it are included in the hidden polyglot.

Given the languages and the scrambled programand the sample program, robbers have to find the polyglot (or a polyglot that has the same behavior as the one the cop wrote).

Rules

  • Any language chosen must be able to be run on TIO, repl.it, ideone, or someplace else online. If the language is obscure, please provide a link to some such website.
  • Any language used must have documentation on Esolangs, Wikipedia, GitHub, or someplace else. Unless the language is very commonly used and has tons of tutorials everywhere, such as Java, Haskell, or C, please provide a link to documentation. Any feature used in the program must be included in that documentation - it shouldn't be something people have to dig through layers of source code to find.

Questions for meta:

  • Is this too easy/hard? Should I not include the extra A program? Should I only make it for 2 languages?
  • Is there anything unclear about the instructions? How can I improve the phrasing?
  • Should cops also give the length of their programs as an extra hint?
\$\endgroup\$
3
  • 1
    \$\begingroup\$ one thing to consider: you would need some way of restricting languages that are allowed. Otherwise people could just make up their own languages or use really, really obscure languages. \$\endgroup\$ – thesilican Aug 18 '20 at 23:04
  • 2
    \$\begingroup\$ IIRC, the usual way to limit the language list is to specify "the language should be on at least one of Wikipedia, TIO, or esolangs.org", though esolangs is already crazy these days. \$\endgroup\$ – Bubbler Aug 19 '20 at 5:05
  • \$\begingroup\$ @Bubbler Yup, I've edited my question with some restrictions now \$\endgroup\$ – user Aug 20 '20 at 15:01
0
\$\begingroup\$

Terminal Punch Card

moved because apparently it's not clear enough.

So back in the day, computers didn't have fancy keyboard and mouse inputs, and didn't have your fancy screens. Instead they had punch cards.

Punch card

Punch cards punchers punched (try saying that 10 times fast) a hole out of a card to represent a 1-bit, and left it filled to represent a 0-bit. The cards were some number of holes wide, with each hole representing a bit in a byte.

Recently, you discovered an old mainframe at your local university that accepted punch cards that were 8 holes wide. For this challenge, you will be given data as an input, and your job is to punch a punch card to the terminal output, like this:

Hello, World!

: *  *   :
: **  * *:
: ** **  :
: ** **  :
: ** ****:
:  * **  :
:  *     :
: * * ***:
: ** ****:
: ***  * :
: ** **  :
: **  *  :
:  *    *:

The input will be a string or bytes representing the punched data payload. The output data must include rows, which start and end with a :, and have 8 bits between them, represented as a for 0, or a * for 1. There must be one row for each byte of data.

Here's the catch: The punch card puncher only punched one hole at a time, so in your program, must print (or add to the output string) only one character at a time.

Example of unacceptable method call:

# `binary` is some string with the binary bits.
print(":" + binary.replace("0", " ").replace("1", "*") + ":")

Acceptable method call:

for bit in binary:
   print(bit == "1" ? "*" : " ", "")

Also acceptable method call:

output = ""
for bit in binary:
   output += bit == "1" ? "*" : " "

The challenge is code golf, so least number of bytes wins. Standard rules/loopholes are in effect.

\$\endgroup\$
4
  • 4
    \$\begingroup\$ A word about catches before we even discuss observability and clarity issues: Catches are rarely a good idea for two reasons. The first is that challenge writers frequently add catches because they somehow feel their challenge is deficient or too easy and want to salvage it somehow. This coping mechanism usually fails, they are better off writing a new challenge. \$\endgroup\$ – Wheat Wizard Mod Oct 4 '20 at 12:17
  • 3
    \$\begingroup\$ Note also there are already comments here regarding observability, assuming language features, and assuming implementation details \$\endgroup\$ – Luis Mendo Oct 4 '20 at 12:19
  • 4
    \$\begingroup\$ The second, which I think is more relevant to you, is that structuring your challenge with a catch is often confusing. You have already written what is a complete challenge, but then in the last 10% or so the whole task changes. Some people don't read the whole challenge once they think they have it, miss the last bit or become frustrated when things are pulled out from under them. Regardless of how you feel about these people, It is really just better to phrase your challenge in a straight forward and upfront way. Nothing should seem tacked on if you can avoid it. \$\endgroup\$ – Wheat Wizard Mod Oct 4 '20 at 12:21
  • 3
    \$\begingroup\$ One way you could easily make your catch observable is to take a string and an index and output the character at that index. Of course answerers can just produce the entire string and index it, but they could already do that with your existing version (probably, it's a little unclear). \$\endgroup\$ – Wheat Wizard Mod Oct 4 '20 at 12:26
0
\$\begingroup\$

Socially distanced seating

Lord Lloyd Warbler wants to minimise the harm to his theatre's seating capacity for his hit show, Birds, of maintaining social distancing.

The social distancing rules in Westendland are:

  • Groups may sit together without distancing
  • Between groups there must be at least 2 empty seats along the row, and 1 empty row in front and behind.
  • The closest diagonal permitted is a knight's move - only 1 horizontal space empty.

Diagrams:

 A _ _ B

 A
 _
 B

 A _ _
 _ _ B

Given a list of group sizes and the theatre size (rows and columns), can you pack them all into the theatre? Groups can sit in any contiguous (connected) arrangement of seats.

Sample tests

(Rows, cols), [groups] -> canFitBool
(1,1), [1] -> true
(2,2), [1,1] -> false
(2,3), [1,1] -> true   // knight's move
(5,2), [4,4] -> true   // 2x2 in rows a,b, gap in c, 2x2 in d,e

questionmarks

  • Should I just provide a list of cases of varying difficulty? Like, some of these could be pretty difficult.
  • Is the knight's move rule too complicated?
  • Is the contiguous rule too permissive, and therefore complicated? It could mean some edge cases are possible if you have a weird shaped group. Could make it rectangular blocks only?
\$\endgroup\$
1
  • \$\begingroup\$ Groups can sit in any contiguous (connected) arrangement of seats You need to decide, and specify in the text, if contiguous means 4-connectivity (up, down, left, right) or 8-connectivity (diagonals count as connected too) \$\endgroup\$ – Luis Mendo Oct 4 '20 at 12:17
0
\$\begingroup\$

Count the strokes of an ASCII character

Objective

Given a printable ASCII character (0x21 – 0x7E), count its strokes (as handwritten), then output it.

Note: The strokes are based on how I write the characters. Those with potential controversy are marked * below.

Mapping

       ! → 2  " → 2  # → 4  $ → 2* % → 3* & → 1* ' → 1
( → 1  ) → 1  * → 3* + → 2  , → 1  - → 1  . → 1  / → 1
0 → 1* 1 → 1* 2 → 1  3 → 1  4 → 2  5 → 2  6 → 1  7 → 2*
8 → 1* 9 → 1  : → 2  ; → 2  < → 1  = → 2  > → 1  ? → 2
@ → 1  A → 3* B → 2  C → 1  D → 2  E → 3* F → 3  G → 2
H → 3  I → 3* J → 1* K → 2* L → 1  M → 4* N → 3* O → 1
P → 2  Q → 1* R → 2  S → 1  T → 2  U → 1  V → 1  W → 1
X → 2  Y → 2  Z → 2* [ → 1  \ → 1  ] → 1  ^ → 1  _ → 1
` → 1  a → 1  b → 1  c → 1  d → 1* e → 1  f → 2  g → 2*
h → 1  i → 2  j → 2  k → 2  l → 1  m → 1  n → 1  o → 1
p → 1  q → 1  r → 1  s → 1  t → 2  u → 1  v → 1  w → 1
x → 2  y → 2  z → 2* { → 1  | → 1  } → 1  ~ → 1

Rule

  • Every character outside of U+0021 – U+007E falls in don't care situation.
\$\endgroup\$
5
  • 1
    \$\begingroup\$ There's no requirement for the *s, because people have to follow your specification anyway. If there's a way to solve this beyond simple compression, then this challenge will be good. \$\endgroup\$ – Razetime Oct 15 '20 at 6:29
  • \$\begingroup\$ Can we take input as an ASCII codepoint? \$\endgroup\$ – pxeger Oct 15 '20 at 16:11
  • \$\begingroup\$ Also can I just say how the hell do you write Q with only one stroke? \$\endgroup\$ – pxeger Oct 15 '20 at 16:17
  • \$\begingroup\$ Does "don't care" mean "assume we won't be given this" or "it doesn't matter what you output"? \$\endgroup\$ – pxeger Oct 15 '20 at 16:17
  • \$\begingroup\$ @pxeger ASCII codepoint is acceptable. "Don't care" means both. For the Q, the tail bisects the bowl, so it can be written in one stroke. \$\endgroup\$ – Dannyu NDos Oct 15 '20 at 21:06
0
\$\begingroup\$

Position my geohashes

The Challenge

This is the reverse challenge of Geohash my positions. Given a Geohash string of length 8, convert it to a latitude and a longitude. The conversion is done by the following algorithm, using u09tunqu as an example input.

  • For each character of the Geohash string, find its 0-indexed position in the map 0123456789bcdefghjkmnpqrstuvwxyz.
    • u09tunqu becomes 26 0 9 25 26 20 22 26
  • Convert each integer into a binary string of length 5.
    • 26 0 9 25 26 20 22 26 becomes 11010 00000 01001 11001 11010 10100 10110 11010
  • Join the binary strings together.
    • 11010 00000 01001 11001 11010 10100 10110 11010 becomes 1101000000010011100111010101001011011010
  • Separate the odd positions in the joined binary string from the even positions. These represent the longitude and latitude, respectively.
    • 1101000000010011100111010101001011011010 becomes 10000001101000011011 (odd positions: longitude) and 11000101011111001100 (even positions: latitude).
  • The latitude should be somewhere in the range (-90, 90). Narrow down the range, based on the first character in the latitude binary string. If the first character is 0, the latitude should converge to the lower half of this range, i.e. (-90, 0). If the first character is 1, the latitude should converge to the upper half of this range, i.e. (0, 90).
    • The 1st character in 11000101011111001100 is 1, so the new range becomes (0, 90).
  • The remaining characters in the binary string are to be processed in the same way, where 0 represents the lower half of the new range and 1 represents the upper half of the new range.
    • The 2nd character in 11000101011111001100 is 1, so the new range becomes (45, 90).
    • The 3rd character in 11000101011111001100 is 0, so the new range becomes (45.0, 67.5).
    • The 4th character in 11000101011111001100 is 0, so the new range becomes (45.0, 56.25).
    • The 5th character in 11000101011111001100 is 0, so the new range becomes (45.0, 50.625).
    • The 6th character in 11000101011111001100 is 1, so the new range becomes (47.8125, 50.625).
    • ...
    • The 20th character in 11000101011111001100 is 0, so the final range becomes (48.85826, 48.85843).
  • The final latitude is the midpoint of the final range.
    • (48.85826, 48.85843) becomes 48.85835
  • Repeat the same process for the longitude, starting from the range (-180, 180)
    • 10000001101000011011 becomes 2.29460
  • Output the final latitude and longitude.
    • u09tunqu becomes 48.85835, 2.29460

Input

A string of length 8, consisting only of the characters 0123456789bcdefghjkmnpqrstuvwxyz.

Output

Two signed floats in the ranges (-90.0, 90.0) and (-180.0, 180.0) representing the corresponding latitude and longitude.

Test cases

u09tunqu → (48.85835, 2.2946)
dr5r7p62 → (40.68933, -74.04459)
stq4s8cf → (29.97525, 31.13783)
75cm2txp → (-22.9519, -43.21043)
usdkfsq8 → (71.17089, 25.78302)
zzzzzzzz → (89.99991, 179.99983)
00000000 → (-89.99991, -179.99983)
ezs42s00 → (42.60507, -5.60286)
7zzzzzzz → (-0.00009, -0.00017)

General remarks

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

AOG Day 6: Filtering the Playlist

I promise the next one will be better

You've sent the invitations for the party (and made the postperson do a whole lot more work than they should have, smh), made the decorations as interesting as possible (who doesn't love a painstakingly written quine) and made sure that the event won't kill anyone (at least, not due to COVID). The next thing that needs to be planned is the music.

Now, of course, you could go ahead and create a YouTube playlist by hand, but that's way too tedious and, well, predictable. Instead, you've decided to write a program that randomly chooses songs from the music genre (I know...very efficient isn't it).

But of course, there's just one problem with that plan: there's a very small chance that a song selected at random might just ruin the party vibes for everyone (even though people such as myself would consider it a Christmas miracle, others would probably see it as a lame stunt and potentially leave the party).

Thankfully, the magic of code allows us to check the html of the YouTube video before hand to tell if it is indeed a rickroll.

The Challenge

Given a YouTube link as input (not shortened, but a full standard link), retrieve the title and description of the video and output whether or not it is a rickroll. In order for a video to be considered a rickroll, it must have either the unbroken phrase Never Gonna Give You Up or Rickroll in the title or description.

Test Cases

Under construction

\$\endgroup\$
1
  • \$\begingroup\$ How about checking the top 5 comments for the unbroken phrase Never Gonna Give You Up or Rickroll as well? Would that make it inconsistent? \$\endgroup\$ – Razetime Nov 12 '20 at 13:25
0
\$\begingroup\$

English Stroke Count Alphabet

In a Chinese glossary/index for any given book, to find terms that are contained within the book and because Chinese doesn't have an alphabet like in English, they are sorted by stroke count instead. (一畫 = 1 stroke,二畫 = 2 strokes,三畫 = 3 strokes,四畫 = 4 strokes,and so on)

An English glossary, having an alphabet, is naturally sorted alphabetically. For this challenge, we flip that idea to the Chinese manner. And we'll follow some Chinese writing rules to help determine stroke order for the alphabet below.

Take 口 (kou) for example, a simple square. You'd think it is 4 strokes, but it is actually 3. The 1st being the left vertical line, the 2nd being the top horizontal and right vertical in one fluid stroke, and the 3rd being the lower horizontal line. This pattern, among others, holds relatively true across Chinese characters. For sake of simplicity though, and for some diversity in the English Stroke Count Alphabet, this will be the primary pattern used.

First, I need to define stroke count for each letter. For sake of simplicity, and somewhat subjectively, I'll use the characters as they appear below. If there are any arguments why a letter should have a different stroke count, please make your case, but in order to promote diversity in stroke counts, I made some personal judgment calls. These stroke counts could easily change with different fonts.

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

3 3 1 2 4 3 2 3 3 1 3 2 4 3 1 2 2 3 1 2 1 2 4 2 3 3

a b c d e f g h i j k l m n o p q r s t u v w x y z

2 2 1 2 2 2 2 2 3 2 3 2 3 2 1 2 2 2 1 2 2 2 4 2 2 3

Letters with equal stroke counts should retain the original alphabetic order as before. So the English Stroke Order Alphabet is as follows. (If I made an error, please say as much, there are a lot of examples that I might have to adjust)

C J O S U D G L P Q T V X A B F H I K N R Y Z E M W

c o s a b d e f g h j l n p q r t u v x y i k m z w

The Challenge Given a non-empty string input containing a sentence/series of words, or a list of words, organize all words according to this new English Stroke Count alphabet. Output can be either a string, or a list of properly words is a single string of properly organized words, including duplicates should they exist.

Note 1: If upper and lowercase for the same letter have the same stroke count, uppercase letters take precedence.

  • "Cousin" precedes "cousin"
  • "father" precedes "Father" (because lowercase f is 2 strokes, while the uppercase is 3)
  • "Stop" precedes "soap" (while the o would precede t in stroke count, uppercase S precedes lowercase s)
  • KO precedes kO (K precedes k)
  • kO precedes ko (O precedes o)

Note 2: I've intentionally avoided weird words in input. Inputs such as "WeIrD", "COVID-19". Input will never include any numbers, punctuation, or special characters.

Input / Output

"It was the best of times it was the worst of tImes" / "of of best the the tImes times It it worst was was"

["When", "life", "gives", "you", "lemons", "make", "Lemonade"] / ["gives", "Lemonade", "lemons", "life", "you", "When", "make"]

[The, journey, of, a, thousand, miles, begins, with, one, step,] / [of, one, step, The, a, begins, journey, thousand, miles, with]

"English Stroke Count Alphabet" / "Count Stroke Alphabet English"

"A man a plan a canal panama" / "canal a a panama plan A man"

"Carry on my wayward son" / "Carry on son my wayward"

"Close our store and begin destroying every flower green house just lose no people quietly rather than using vexing xrays yesterday it killed my zoo wombat" / Same as input (If you can write a better sentence than above, I'd be much appreciated.)

["May", "the", "Force", "be", "with", "you"] / ["be", "the", "you", "Force", "May", "with"]

[Im, going, to, make, him, an, offer, he, cant, refuse] / [cant, offer, an, going, he, him, refuse, to, Im, make]

"jello Jello JellO JEllo JELlo JELlO JELLO" / "JellO Jello JELLO JELlO JELlo JEllo jello"

"We suffer more often In imagination than IN reality" / "often suffer reality than In IN imagination more We"

"Code Golf and Coding Challenges" / "Code Coding Challenges Golf and"

["Do", "or", "DO", "not", "there", "is", "no", "try"] / ["or", "DO", "Do", "no", "not", "there", "try", "is"]

"Failure the best teacher is" / "best teacher the Failure is"

"Can you tell that I am a Star Wars fan" / "Can Star a am fan tell that you I Wars"

[enough examples no more words] / [enough examples no more words]

\$\endgroup\$
10
  • \$\begingroup\$ If I is 3, then surely i is 4, no? Similarly for J vs j. \$\endgroup\$ – Adám Nov 2 '20 at 21:32
  • \$\begingroup\$ You should be more lenient about input. E.g. allow a list of words. \$\endgroup\$ – Adám Nov 2 '20 at 21:34
  • \$\begingroup\$ "Uppercase letters take precedence when determining stroke counts, should they be equal." means there's just a single case-sensitive alphabet. It'd be more interesting if uppercase matching lowercase on stroke counts would only be used as a tie breaker. \$\endgroup\$ – Adám Nov 2 '20 at 21:37
  • \$\begingroup\$ @Adám As per point 1, I can see the argument. I can make that change, but it'll likely take a second to get all of the examples in line. Point 2, that input format seems adequate. Point 3, I think I know what you mean. And I'm pretty certain that that's what I was intending, but I had poor wording. \$\endgroup\$ – Sumner18 Nov 2 '20 at 21:49
  • \$\begingroup\$ No rush. I recommend sandboxing for at least one week. \$\endgroup\$ – Adám Nov 2 '20 at 21:52
  • 1
    \$\begingroup\$ You should add KD vs kO and kO vs ko to the examples for Note 1. \$\endgroup\$ – Adám Nov 2 '20 at 21:53
  • \$\begingroup\$ I'm not sure what you mean by "that input format seems adequate", but please familiarise yourself with this. \$\endgroup\$ – Adám Nov 2 '20 at 21:55
  • \$\begingroup\$ @Adám I'd like to add one thing about how stroke count works in Mandarin. 口 (kou) in Mandarin appears to be a square, and you'd think it has 4 strokes, but it actually has 3. The 1st stroke is the left vertical line, the 2nd stroke is the top horizontal and right vertical line, and the 3rd and final stroke is the bottom horizontal line. These patterns hold fairly true across Chinese characters. In the case of the letter i, I actually see 3 strokes instead of your suggested 4. The 1st being the slight horizontal tick and vertical line, the 2nd being the bottom line, and the 3rd for the dot. \$\endgroup\$ – Sumner18 Nov 2 '20 at 21:57
  • 1
    \$\begingroup\$ I see, but then J should be 1, no? 一丿 \$\endgroup\$ – Adám Nov 2 '20 at 21:59
  • \$\begingroup\$ @Adám Correct, I wasn't necessarily thinking of that when I made the challenge, but I'll add the explanation and make the edit. \$\endgroup\$ – Sumner18 Nov 2 '20 at 22:02
0
\$\begingroup\$

Make a die of given number of faces

Objective

Given an integer \$n\$ greater than 3, identify an \$n\$-sided die with the "greatest" symmetry, then decompose \$n\$ to numbers of faces grouped up to the symmetry, and then output the decomposition.

Symmetry

A die can have one of the following symmetries, from the greatest and with descending order:

  • \$I_h\$, icosahedral symmetry

  • \$O_h\$, octahedral symmetry

  • \$T_d\$, tetrahedral symmetry

  • \$D_{ph}\$, \$p\$-fold prismatic symmetry, in ascending order on \$p\$, where \$p\$ is an odd prime number

Note that every other symmetry is redundant.

Faces

A die of each symmetry can have the following faces:

  • For a die of symmetry \$I_h\$:

  • For a die of symmetry \$O_h\$:

  • For a die of symmetry \$T_d\$:

  • For a die of symmetry \$D_{ph}\$:

    • Optionally \$2\$ faces, those from base faces of a \$p\$-gonal prism

    • Optionally \$p\$ faces, those from side faces of a \$p\$-gonal prism

    • Optionally \$2p\$ faces, those from a \$p\$-gonal bipyramid

    • Zero of more sets \$4p\$ faces, those from a \$2p\$-gonal bipyramid

Note that faces from the Catalan solids that are not mentioned here are redundant.

Rules

  • The input and output format doesn't matter. Possible choices of output format include:

    • A list, sorted or unsorted

    • A multiset

  • Invalid inputs fall in don't care situation. Especially, integers that are 3 or less.

Examples

  • For \$n=4\$, the die has \$T_d\$ symmetry, so \$n\$ decomposes to \$(4)\$, with the die being a tetrahedron.

  • For \$n=5\$, the die has \$D_{3h}\$ symmetry, so \$n\$ decomposes to \$(2,3)\$, with the die being a triangular prism.

  • For \$n=6\$, the die has \$O_h\$ symmetry, so \$n\$ decomposes to \$(6)\$, with the die being a cube.

  • For \$n=7\$, the die has \$D_{5h}\$ symmetry, so \$n\$ decomposes to \$(2,5)\$, with the die being a pentagonal prism.

  • For \$n=8\$, the die has \$O_h\$ symmetry, so \$n\$ decomposes to \$(8)\$, with the die being an octahedron.

  • For \$n=9\$, the die has \$D_{3h}\$ symmetry, so \$n\$ decomposes to \$(3,6)\$, with the die being a truncated triangular bipyramid. Note that the die won't have \$D_{7h}\$ symmetry because \$D_{3h}\$ is greater.

  • For \$n=10\$, the die has \$T_d\$ symmetry, so \$n\$ decomposes to \$(4,6)\$, with the die being a chamfered tetrahedron. Note that this is different than the usual d10, which is a pentagonal trapezohedron.

  • For \$n=11\$, the die has \$D_{3h}\$ symmetry, so \$n\$ decomposes to \$(2,3,6)\$.

  • For \$n=12\$, the die has \$I_h\$ symmetry, so \$n\$ decomposes to \$(12)\$, with the die being a dodecahedron. Note that due to the greater symmetry, dodecahedron supersedes rhombic dodecahedron and triakis tetrahedron.

  • For \$n=100\$, the die has \$T_d\$ symmetry, so \$n\$ decomposes to \$(4,24,24,24,24)\$. Note that this is different than usual Zocchihedron, which has prismatic symmtery.

Note that, if \$p\$ and \$p+2\$ are twin primes, \$p+2\$ will always decompose to \$(2,p)\$.

Ungolfed solution

Haskell

This implementation mimics the ReadP parser.

import Control.Monad

type DResult = [([Int], Int)]
type DParser = DResult -> DResult

returnD :: Int -> DResult
returnD n = [([],n)]

pfail :: DParser
pfail _ = []

get :: Int -> DParser
get m results = do
    (ns, n) <- results
    guard (m <= n)
    return (m:ns, n - m)

many :: DParser -> DParser
many p results = let
    results2 = p results
    in case results2 of
        [] -> results
        _  -> results ++ many p results2

optional :: DParser -> DParser
optional p results = p results ++ results

run :: DParser
run = filter ((0==) . snd)

(<++) :: DParser -> DParser -> DParser
(<++) p q results = case p results of
    [] -> q results
    results2 -> results2

decomposeDph :: Int -> DParser
decomposeDph prismFold = run . optional (get 2) . optional (get prismFold) . optional (get (2*prismFold)) . many (get (4*prismFold))

decomposeTd :: DParser
decomposeTd = run . optional (get 4) . optional (get 6) . optional (get 12) . many (get 24)

decomposeOh :: DParser
decomposeOh = run . optional (get 6) . optional (get 8) . optional (get 12) . optional (get 24) . many (get 48)

decomposeIh :: DParser
decomposeIh = run . optional (get 12) . optional (get 20) . optional (get 30) . optional (get 60) . many (get 120)

decomposeDie :: Int -> [Int]
decomposeDie n = fst . head $ foldr (<++) pfail (decomposeIh : decomposeOh : decomposeTd : map decomposeDph [3,5..]) (returnD n)
\$\endgroup\$
0
\$\begingroup\$

Topologies on Rational Numbers (WIP)

Objective

Construct a subset \$P\$ of \$\mathbb{Q}\$ such that:

  • \$P\$ is neither open nor closed in \$\mathbb{Q}\$ as a subspace of \$\mathbb{R}\$, and

  • \$P\$ is open but not closed in \$\mathbb{Q}\$ as a subspace of \$\mathbb{R}_l\$.

Or, in other words, construct a subset \$P\$ of \$\mathbb{Q}\$ such that:

  • There exists \$p \in P\$ such that, there doesn't exist an open interval \$p \in (a,b) \subset \mathbb{R}\$ such that, \$\mathbb{Q} \cap (a,b) \subset P\$.

  • For every \$p \in P\$, there exists a half-open interval \$p \in [a,b) \subset \mathbb{R}\$ such that, \$\mathbb{Q} \cap [a,b) \subset P\$.

  • There exists \$p \in \mathbb{Q} \setminus P\$ such that, there doesn't exist a half-open interval \$p \in [a,b) \subset \mathbb{R}\$ such that, \$\mathbb{Q} \cap [a,b) \subset \mathbb{Q} \setminus P\$.

Notes and Rules

  • Note that \$P\$ is necessarily infinite, and thus cannot be represented as an associative container. One way of representing \$P\$ is to have a function \$f : \mathbb{Q} → \mathbb{Z}_2\$ that halts for every input, where \$\mathbb{Z}_2\$ is the set of the boolean values. Then \$p \in P\$ shall satisfy iff \$f(p)\$ is true.

  • The representation of \$\mathbb{Q}\$ must be exact. Thus you cannot have floating-point values as an input. Though native rational-number arithmetic will be preferred, you may use two arbitrary-length integers as an input. In this case, the fraction is assumed to be irreducible and to have a positive denominator. Otherwise, the fraction falls in don't care situation.

  • Invalid inputs fall in don't care situation.

Example

An example of such \$P\$ is:

$$ \mathbb{Q} \cap ((0,1) \cup [2,3)) $$

Work in progress due to a trivial example.

\$\endgroup\$
1
  • 1
    \$\begingroup\$ Is there a way you can frame this question without topology? At the moment I think participation would be very low due to the high background knowledge demanded. \$\endgroup\$ – Sisyphus Nov 10 '20 at 9:58
0
\$\begingroup\$

Find the longest streak of Fibonacci numbers on the Ulam spiral

Fibonacci numbers

Fibonacci numbers are a sequence where each element is the sum of the previous two elements. In the original Fibonacci sequence, the first two number are 1. So the sequence goes: 1, 1, 2, 3, 5, 8, 13, 21, .... For the challenge, we will accept any two numbers as the two starting numbers of the series.

Ulam spiral

The Ulam spiral is an arrangement of natural numbers. The spiral goes counter-clockwise and starts with the numbers 1, 2, where the 2 is right of the 1. For this exercise, only the shape of the spiral is relevant.

Ulam spiral

Task

Find the length of the longest streak of generalised Fibonacci numbers (with any two starting numbers) following the Ulam spiral in a given array of integer numbers.

Example

The following 5x5 array has two generalised Fibonacci sequences: one of length 4 (in blue + yellow: 138, 81, 219, 300) and one of length 8 (in green + blue: 24, 57, 81, 138, 219, 357, 576, 933). The answer is thus 8.

Example

Rules

  • Your program should at least support arrays up to 65535 * 65535 in size and array elements with values up to 4,294,967,295.
  • Invalid input (non-square arrays, float or negative elements, non-arrays, etc.) may lead to unpredicted output, errors or (un)defined behaviour.
  • Default I/O rules apply and default loopholes are forbidden.

on question 1; see comments below

  • This is , so the shortest answer in bytes wins.

on question 2; see comments below

  • This is , so the fastest answer wins.
  • Fastest code is measured in average user time over 5 different, undisclosed input matrices of sizes 100, 1000 and 10,000, each run 3 times on my late 2013 MacBook Pro with 2,3 GHz quadcore Intel i7 CPU and 16 GB of RAM.

Review questions

  • I plan on publishing this question twice: one time as a codegolf and one time as a fastest-code. See the last section of my question. I think this challenge has interesting but very different optimization strategies for speed and size. Is this be something that would be frowned upon by the CGSE community?
  • Is the challenge clear enough as stated?
  • Should I add more/larger test cases? Or a test case generating Python script?
\$\endgroup\$
0
\$\begingroup\$

Isomorphic Modular Arithmetic

For this question, we define \$U(n)\$ as the group consisting of a number below \$n\$ that is coprime to n (1 included but 0 doesn't) and multiplication as group operator.

Your task is to print every integer (so it's an infinite loop, but there should be output during looping) and group it into lines so that:

  1. The line consists of a sequence of sorted number so that the \$U\$ group based on each number is isomorphic
  2. The output itself has to be sorted based on the first number on each line
  3. Every number have to be eventually outputted given enough time.

A pair of groups \$(X,\times_A)\$ and \$(X,\times_B)\$ is called isomorphic if there is a pair of functions \$f : X\to X\$ and \$g:X\to X\$ so that:

\$ f(g(x)) = x = g(f(x)) \text{ (i.e. they are inverses)} \$

\$ f(x) \times_B f(y) = f(x \times_A y) \$

\$ g(x) \times_A g(y) = g(x \times_B y) \$

The shortest code wins.

Example

U(2) consists of only one element 1. U(3) and U(4) is isomorphic because both contains only 2 elements (former 1, 2 and latter 1, 3. 2 is excluded because 2 divides 4) and the table of multiplication is identical aside of replacement of 2 and 3. Less trivially U(8) and U(12) is isomorphic, but not U(5) the elements of U(8) is 1,3,5,7 the elements of U(12) is 1,5,7,11 the elements of U(5) is 1,2,3,4 Look at the table of multiplication:

    U(8)          U(12)          U(5)     
  1 3 5 1       1  5  7 11     1 2 3 4
1 1 3 5 7    1  1  5  7 11   1 1 2 3 4
3 3 1 7 5    5  5  1 11  7   2 2 4 1 3
5 5 7 1 3    7  7 11  1  5   3 3 1 4 2
7 7 5 3 1   11 11  7  5  1   4 4 3 2 1

By replacing 1 <-> 1, 3 <-> 5, 5 <-> 7, 7 <-> 11, the table of multiplication for U(8) and U(12) is identical. U(8) and U(5) is not, as n * n = 1 for any n in U(8), but 22 = 4 and 11 = 1 in U(5). If there is such a pair f : U(8) -> U(5) and g : U(5) -> U(8), then g(22)=g(4) <=> g(2)g(2)=g(4) <=> 1 = g(4) <=> g(1) * g(1) = g(4) <=> g(11) = g(4) <=> f(g(11)) = f(g(4)) <=> 1*1=4 <=> 1=4, which is a contradiction.

Even less obviously U(7) and U(9) are isomorphic, the multiplication table is:

   U(7)           U(9)
1 3 2 5 4 6   1 2 4 5 7 8
3 2 6 1 5 4   2 4 8 1 5 7
2 6 4 3 1 5   4 8 7 2 1 5
5 1 3 4 6 2   5 1 2 7 8 4
4 5 1 6 2 3   7 5 1 8 4 2
6 4 5 2 3 1   8 7 5 4 2 1

Aside of swapping the row and column (has been done) and relabeling, the multiplication table is identical, So, they are symmetric

Output for 2-15

2
3 4 6
5 10
7 9
8 
11
13
14
15
\$\endgroup\$
4
  • \$\begingroup\$ Your opening sentence doesn't quite define a group. Do you mean a group generated by the coprime and multiplication? It seems like the most logical choice. \$\endgroup\$ – Wheat Wizard Mod Nov 24 '20 at 14:55
  • \$\begingroup\$ I am starting to doubt that since the result is always isomorphic to the integers under addition, and completely ignores n. Do you maybe mean the group generated by the coprime and multiplication on the cyclic group of order n? This makes more sense, but not a whole ton of sense. I think if you explained the output requirements more directly it would be easier. As it stands I do not understand them at all. \$\endgroup\$ – Wheat Wizard Mod Nov 24 '20 at 15:19
  • \$\begingroup\$ @WheatWizard I mean group generated by coprime and multiplication on the cyclic group of order n \$\endgroup\$ – Xwtek Nov 25 '20 at 10:43
  • \$\begingroup\$ You still haven't actually changed the problem statement. \$\endgroup\$ – Wheat Wizard Mod Nov 28 '20 at 21:04
0
\$\begingroup\$

Use the wrong paradigm

This is just a general idea, I don't know how you would go about scoring it or what the goal would be, but I think it would be fun to see stuff like oop in haskell.

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

Golfing on a Budget

The Task

Every answer should take a positive number as input, and print/return every number in reverse down to zero (inclusive), in any reasonable format. For example:

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

The requirements

Every program has $100 to spend.

The cost of each byte is determined by \$2^{t-1}\$, where \$t\$ is the number of times the byte has appeared in previous programs in addition to the current one.

For example, assuming it's the first program, x->x++ would cost $10. Each - and > are $1, and each x and + are $2.

\$\endgroup\$
3
  • 2
    \$\begingroup\$ In some sense, doesn't this become a contest of speed to solution? The earlier I post, the lower my score. It also severely advantages certain languages that don't use ASCII. \$\endgroup\$ – Xcali Dec 3 '20 at 4:17
  • \$\begingroup\$ Also, what's the criteria for winning? What is the reason for the $100? \$\endgroup\$ – Xcali Dec 3 '20 at 4:25
  • \$\begingroup\$ @Xcali This is currently a very rough idea, so I didn't have any winning criterion decided on yet. What I was trying to do was make it so that it would be harder to come up with valid answers as time went on, but I think the execution ended up really bad here. \$\endgroup\$ – Redwolf Programs Dec 3 '20 at 4:27
0
\$\begingroup\$

Perfect radicals

  • Posted

Perfect radicals

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

Posted to the main forum

\$\endgroup\$
4
  • 1
    \$\begingroup\$ We do have occasional fastest code challenges, and many of them get great answers. For objective scoring, (unfortunately) it is necessary to score it on your machine because the specifics of OS/CPU/RAM/storage device/whatever can change the relative run time of two programs. One suggestion is to use smaller test cases (reduce board size and number of ships) so that programs can be tested without waiting for hours. \$\endgroup\$ – Bubbler Dec 1 '20 at 10:01
  • \$\begingroup\$ I can, for instance. set up a Linux virtual machine for the tests. And yes, it is possible to parameterise so as to have a scale of complexity: highest complexity gives authoritative score but lower ones used for weeding. \$\endgroup\$ – user46773 Dec 1 '20 at 15:07
  • 1
    \$\begingroup\$ I'd suggest posting a valid board as the example and then a separate invalid one to illustrate that point. \$\endgroup\$ – Xcali Dec 3 '20 at 4:21
  • \$\begingroup\$ @Xcali - good point. I will do that. \$\endgroup\$ – user46773 Dec 3 '20 at 13:01
0
\$\begingroup\$

Play the percussion for Ravel's Boléro

rhythm

The Boléro by Maurice Ravel is a piece of music characterised by a consistent snare drum pattern, repeated over and over, at unchanging tempo. This task is very challenging for a human performer, who must maintain the beat without rushing the tempo, or increasing the volume too quickly.

That's why you're going to write a program to do it!

I want your program to do something at the tempo and rhythm specified. It can output a key to a console, produce a beep, make a window pop up, have a graphical display flash colour; anything at all is acceptable, as long as it is A) observable to a human, and B) does not need human interaction for the program to continue. So if you make a pop-up, you should not require someone to click it away before the next pop-up can appear.

Using a tempo of 60 bpm (a bit slow but Ravel liked it played slowly), the whole rhythm takes exactly 6 seconds to play through. Here are the timings for when your program must send out some kind of signal, the unit being seconds. I'll tolerate divergences from the ideal of up to 0.02 seconds in either direction.

0.00
0.50
0.67
0.83
1.00
1.50
1.67
1.83
2.00
2.50
3.00
3.50
3.67
3.83
4.00
4.50
4.67
4.83
5.00
5.17
5.33
5.50
5.67
5.83
6.00

Note that here the final beat, at exactly 6 seconds, is the first beat of the next iteration of the rhythm; the next percussion hit occurs at 6.50, then 6.67, and 6.83, etcetera.

So, make your program produce that rhythm indefinitely. Choose whatever output you want. It's , so the shortest code wins!


For the sandboxers; I have considered using either this question as is, or having it be a popularity contest with added the stipulations that it ends after 170 repetitions and that the output somehow gradually gets intenser throughout that time, like the music does. The con is that popularity contests are a bit messier; but I would love to see creative ways to display the rhythm.

\$\endgroup\$
4
  • 1
    \$\begingroup\$ You should add an explanation for people who cannot read music; not everyone knows what a triplet is, or what bpm means. \$\endgroup\$ – Robin Ryder Dec 6 '20 at 13:50
  • \$\begingroup\$ @RobinRyder No knowledge of sheet music is needed; the picture is just illustrative. The list of timings is accurate. \$\endgroup\$ – KeizerHarm Dec 6 '20 at 15:29
  • \$\begingroup\$ The list of timings is accurate at 60 bpm, but not at other tempos. \$\endgroup\$ – Robin Ryder Dec 6 '20 at 16:16
  • 1
    \$\begingroup\$ @RobinRyder Very well, I will make 60 bpm the only accepted tempo and just have the timings be the final specification. \$\endgroup\$ – KeizerHarm Dec 6 '20 at 20:09
0
\$\begingroup\$

Simon says "Make me a game"

Forked from this closed question.

Create a "Simon says" game.

Take an input \$n\$, for number of levels, and \$k\$, for number of buttons and do the following:

  • Create a square area for the buttons.(at least 100x100 pixels in size.)

  • Divide it into k rectangular buttons of equal size. k will always be even.

  • Each button should be of a different color, and none of them should be the same color as the background.

  • The game should proceed as follows:

    • Starting level is 1. Level number should be displayed at the top.

    • Get a random order in which the buttons should "light up". The number of clicks should be level number + 4.

    • In that same sequence, display a visual indicator on each button, so the user knows what order they should click the buttons in.

    • There should be at least a 200ms delay between each visual indication.

    • If the user clicks them in the correct order, move on to the next level, and repeat the above steps. Otherwise, display "Game Over" at the bottom of the screen.

Here is a playable demo for k=4, Courtesy of Gabriele D'Antona.


Meta

  • Is this specification clear?

  • Any thoughts/feedback?

  • Should there be a limit on the values of n and k?

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

Animal-Alphabetical Sequence

\$\endgroup\$
2
  • 1
    \$\begingroup\$ Seems like a cool challenge except for the part where you have to start from the googolth element. I'd suggest starting from the beginning instead. \$\endgroup\$ – Beefster Dec 16 '20 at 17:51
  • \$\begingroup\$ Also, JAMBU won't appear anywhere in the output since none of the other animals have Js in them. Same for ZEBRA and maybe others. You might consider choosing different animal names, dropping your 5-letter theme, and ensuring that all 26 letters can possibly exist in the sequence. \$\endgroup\$ – Beefster Dec 19 '20 at 0:12
0
\$\begingroup\$

Answers made up from older answers


In this challenge, your task is to take a number as input, and determine whether it is the number of previous answers. For example, the third answer would print/return a truthy value is given 2, and a falsey value for any other input.

However, all answers must be made up of previous answers. For example, if the existing answers were +1, t()==1, and _=>inpu, some allowed answers would be:

  • t()==1+1
  • _=>input()==1+1
  • +1+1+1+1

Examples of answers that would not be allowed:

  • 1+
  • 1+1
  • _=>+1
  • (newline)

For the output/return format, this is a list of the allowed formats I'll use for this challenge.

Scoring and initial allowed parts of answers coming soon.

Meta

  • What should the title be?
  • Any recommended initial allowed parts?
  • Is this easy to read/understand?
\$\endgroup\$
7
  • \$\begingroup\$ This is understandable, and seems to make a fun challenge. You should probably restrict having the same language twice (although i'm assuming that's implied) because that would make it boring. The title could be like "Answer Recycling" or something, but I'm not very creative with titles. \$\endgroup\$ – Gio D Dec 27 '20 at 6:14
  • \$\begingroup\$ @GioD Oh, I forgot about that, I'll make sure to add that restriction. Thanks for the title suggestion, too! \$\endgroup\$ – Redwolf Programs Dec 27 '20 at 6:16
  • \$\begingroup\$ No problem, I just like the idea of recycling being used in a problem. Are people allowed to submit more than once? because this definitely seems like a fun challenge. My idea of a first program would just be "0" in retina, but that seems like it wouldn't make for a lot of creativity \$\endgroup\$ – Gio D Dec 27 '20 at 6:17
  • \$\begingroup\$ @GioD I'd probably just restrict posting more than one answer in a row. Glad to see there's some interest in this challenge! \$\endgroup\$ – Redwolf Programs Dec 27 '20 at 6:20
  • \$\begingroup\$ My idea for initial characters were "0", "1", " ", newline, and "=" although that might not work as well as I think it would. I'd recommend experimenting, since I'm fairly new to code golfing and i don't know most of the languages out there. \$\endgroup\$ – Gio D Dec 27 '20 at 6:30
  • 2
    \$\begingroup\$ I don't see how the parts list gets expanded with each answer. If it doesn't, how do different answers get created? \$\endgroup\$ – Xcali Dec 29 '20 at 3:07
  • \$\begingroup\$ @Xcali That's an issue I was thinking about, I think my solution will be allowing each answer to add one new part. For example, if the current parts are a, bc, and d, I could answer abcfdabc, so the new parts list would be a, bc, d, abcfdabc \$\endgroup\$ – Redwolf Programs Dec 29 '20 at 3:13
0
\$\begingroup\$

Implement ASCII -> GSM-7 (SMS) text packing

SMS messages can store 160 ASCII characters into 140 characters. It does this by chopping off the top bit from each byte and packing them together.

The simplified steps:

  1. Convert the string to binary little endian ASCII.
  2. Remove the top bit from each byte.
  3. Pack them together so there are no gaps.
  4. If applicable, pad the final byte with zero bits.

So, take the text "Test0123".

First, we convert it to little endian binary.

0x54     0x65     0x73     0x74     0x30     0x31     0x32     0x33
00101010 10100110 11001110 00101110 00001100 10001100 01001100 11001100

Then, we chop off the last (most significant) bit of each octet:

0010101  1010011  1100111  0010111  0000110  1000110  0100110  1100110

Then, we pack them together into a 7 byte array:

0xd4     0xf2     0x9c     0x0e     0x8b     0xc9     0x66
00101011 01001111 00111001 01110000 11010001 10010011 01100110

In the case of bitwise operations, it is a simple funnel shift.

The basic algorithm in C is here for an 8 byte ASCII string. However, your algorithm must accept any length.

void ascii_to_gsm7_8_bytes(uint8_t *buf, const char *str)
{
    buf[0] = (str[0] >> 0) | (str[1] << 7);
    buf[1] = (str[1] >> 1) | (str[2] << 6);
    buf[2] = (str[2] >> 2) | (str[3] << 5);
    buf[3] = (str[3] >> 3) | (str[4] << 4);
    buf[4] = (str[4] >> 4) | (str[5] << 3);
    buf[5] = (str[5] >> 5) | (str[6] << 2);
    buf[6] = (str[6] >> 6) | (str[7] << 1);
}

The input can either be a string (optionally with a provided length) or an input from stdin which is terminated with a newline or EOF.

The string will be a non-empty printable ASCII string that is 160 bytes or less. It is safe to assume that all bytes are 0x20 <= x < 0x80, meaning the last MSB bit is cleared beforehand.

Important: While strings can be null terminated, you are not allowed to use that null terminator for padding the last byte.

Output will be the packed string.

The output can either be printed as a list of values (base 10 or base 16) to stdout or returned in an output array.

Test cases (output is in hex):

Input text -> Output (hex)
"" -> Empty strings do not need to be handled.
"Úñíçódé" -> Unicode does not need to be handled, only ASCII.
"Hi!" -> {0xc8, 0x74, 0x08}
"Test0123" -> {0xd4, 0xf2, 0x9c, 0x0e, 0x8b, 0xc9, 0x66}

More test cases will be added if this is accepted.

This is , so the shortest code in bytes per language wins.

\$\endgroup\$
4
  • 2
    \$\begingroup\$ You should probably provide example input/outputs for so that it's easy for people to test their program and to get a grasp of what the program is asking. \$\endgroup\$ – Gio D Dec 27 '20 at 6:31
  • \$\begingroup\$ I updated the rules to make them more clear, removed the 140 byte requirement, and added an example and a few test cases \$\endgroup\$ – EasyasPi Dec 27 '20 at 22:10
  • \$\begingroup\$ 1. Bonuses to a score are generally frowned upon. 2. I'm confused about the output format. What is needed? 3. Why the null requirement added to the end? I don't see that in the SMS spec. 4. What's the winning criteria? \$\endgroup\$ – Xcali Dec 28 '20 at 17:47
  • \$\begingroup\$ Is this better? \$\endgroup\$ – EasyasPi Dec 28 '20 at 18:45
0
\$\begingroup\$

Isosceles triangle truncations

Most triangles are not isosceles. Here is an example:

A ____ C
 |   /
E|  /
 | /D
 |/
B

However, we can cut this triangle into two smaller triangles, one of which is isosceles. We can do this in a number of ways:

  • By cutting from C to E, we create isosceles triangle BEC. (Due to limitations of ASCII art, you'll just have to imagine that E is in the correct place.)
  • By cutting from A to D, we create isosceles triangle ADB.
  • By cutting from A to D, we create isosceles triangle ADC. (This always happens for right-angled triangles, of course. It's hard to draw ASCII art triangles that are neither right-angled nor isosceles.)

Each triangle can be derived in turn from the original triangle by fixing one of the three sides (which will be the base of the new triangle) and the smaller of the two adjacent angles, adjusting the other base angle as necessary.

Your challenge is, given a triangle of three points A, B and C in any reasonable format, is to output at least one of its isosceles triangle truncations.

It must be possible to obtain all three truncations for a given triangle. This is typically achieved by permuting the parameters of the function, but you can use some other input method if you wish. In any case please indicate how to obtain all truncations.

Example: For an input of (0, 0), (0, 4) and (8, 0), the output might be (0, 0), (4, 2), (8, 0); (0, 0), (0, 4), (4, 2); (3, 0), (0, 4), (8, 0). Alternatively, the output might just be (3, 0), and to obtain (4, 2) you would have to input the triangle in a different order.

You may assume that the input triangle is not isosceles (or equilateral, for those languages that allow parameters that are surds rather than floating-point decimals). For instance, for programs that normally output all truncations, they might simply return a single equilateral triangle unchanged.

Your method should be theoretically exact even if the code suffers from floating-point limitations.

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

\$\endgroup\$
1
96 97
98
99 100
115

You must log in to answer this question.

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