459
\$\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

2568 Answers 2568

0
\$\begingroup\$

Typographic Chemistry

Inspired by this: https://xkcd.com/1442/

Task

You must make a program or function that take input a string from STDIN and output the possible allowed reactions (1 point per unique reaction, see also "Score" below)

Rules

A chemical reaction is allowed if all the "legs" of the elements are used, i.e., there are no unpaired "legs". A "leg" is just the end of a curve in the typographic print of the chemical symbol (see the comic and it should be clear). So for example:

Carbon - C - 2 legs

Oxygen - O - 0 legs

Hydrogen - H - 4 legs

Nitrogen - N - 2 legs

Potassium - K - 4 legs

Phosphorus _ P 1 leg

An element can be rotated, reflected but not stretched in any way, so that the only possible bonds are (here I don't know how to rotate the chars, if somebody can help it would be welcome):

$$CH \;\mathrm{(with\;the\;C\;on\;top\;or\;bottom\;rotated\;by\;90\;degrees)}\\CK \;\mathrm{(with\;the\;C\;on\;top\;or\;bottom\;rotated\;by\;90\;degrees\;or\;to\;the\;right\;rotated\;by\;180)}\\ HK\;\mathrm{(on\;top\;of\;each\;other\;or\;on\;the\;side\;rotating\;one\;by\;180)}\\ NN\;\mathrm{(with\;one\;reflected\;has\;two\;legs\;on\;top\;and\;two\;diconnected\;legs\;on\;bottom)}\\ P\;\mathrm{(with\;anything)}\\ O\;\mathrm{doesn't\;bond}$$

These are the only possible elements passed from STDIN. Notice that the difference between H and K is that K can bond also laterally with a C.

Extra Rule

If no reaction is possible, the output should be equal to the input

Score

1 point per reaction. Bonus: X3 the score if you can print the reaction diagramatically, i.e. print the shape of the molecule (like in the comic)

Example

$$Input \rightarrow Output\\ C\,C \rightarrow (C_2)\\ N \, N \rightarrow N \, N\\ C\,N \, N\,P\,P \rightarrow (C N_2 P_2)\\ C\,C\,K \, H\,H\rightarrow (KC_2H_2)\\ C\,H\,O\rightarrow C\,H\,O $$

\$\endgroup\$
  • \$\begingroup\$ Your rules seem to be imposing extra grid-alignment constraints on the letters (e.g. you don't seem to permit the hydrogen crystal from the xkcd). Does that mean that although P can bond with anything except O, the positions in which it can do so are restricted? \$\endgroup\$ – Peter Taylor Nov 24 '15 at 19:05
  • \$\begingroup\$ Hi, I don't want to impose necessarily the extra grid alignment, thanks for noticing it. Yes, P can bond with anything, I added it so that it is easier to have "allowed" reactions. \$\endgroup\$ – Costantino Nov 25 '15 at 15:01
  • \$\begingroup\$ So does that mean e.g. that CP_2 is possible? \$\endgroup\$ – Peter Taylor Nov 25 '15 at 15:12
  • \$\begingroup\$ yes it is, although I have no idea how you could print it. Do you have any good way to state the rules simply and effectively? \$\endgroup\$ – Costantino Nov 25 '15 at 15:39
  • \$\begingroup\$ This is so far from the truth of chemistry that you really need some decent drawings to show what's acceptable. The number of bonds an atom can make is in reality determined by its column in the periodic table: K=1 (except the bond is usually ionic not covalent), H=1, C=4, N=3, P=3 (sometimes 5), O=2. \$\endgroup\$ – Level River St Nov 25 '15 at 23:25
  • \$\begingroup\$ Hi, I have prepared an image, but I can't upload it because I don't have enough reputation. Can you help me? \$\endgroup\$ – Costantino Nov 26 '15 at 16:06
  • \$\begingroup\$ The easiest solution I can see is to remove entirely the list of possible bonds and the bonus and to effectively convert it into a question of whether there exists a graph with the desired degree sequence. IMO that's still an interesting question, and one which hasn't been asked here before. \$\endgroup\$ – Peter Taylor Nov 26 '15 at 21:08
0
\$\begingroup\$

Note: I think the question is fine. I just need some more testcases for it.



You are given the priority order of alleles for a particular trait. For example,

A B
O

means that A and B are equally dominant and O is recessive to both of them. An organism has exactly two alleles, but only the dominant trait(s) is/are expressed. So an organism with gene AO will express only A but an organism with gene AB will express both A and B. An organism with two same alleles will express that allele only.

Each offspring will receive two alleles - one from the mother and the other from the father. So if the initial parents are AB and AO, the offspring formed will be:

AA - 25%
AO - 25%
AB - 25%
BO - 25%

Expressed traits will be

A - 50%
AB - 25%
B - 25%

Offspring of one generation may breed only with a single member of the opposite sex in the same generation during its lifetime. Assume for the sake of this challenge that every male finds a random female in the same generation and has exactly two children - one male and one female. Siblings may interbreed. Note that, except for the first generation, we can ignore the sex of the individuals as their sex chromosomes assort independently of their other characteristics.

Input

  • Priority order of all alleles (may include unnecesary alleles)
  • Genotype of every organism in initial generation
  • Number of generations created
  • Any one allele
  • (Optional) Number of lines of input for priority order (for languages like C++)

Output

  • Probability of the specified allele existing in a randomly selected individual in the specified generation (accurate to three decimal places)

Challenge

  • Once two/three answers are posted, I'll use the same testcases in all of them to see which of them are faulty.
  • After a week (or I could prolong the deadline) I will upload a lengthy test case in a few days. The code that solves it in the fastest time wins.

Sample data (Some simple testcases)

#1

A
B
C
Male(s) - AA
Female(s) - AB
5
C

Output 0

#2

A
B
C
Male(s) - AA
Female(s) - AB
2
A

Output 0.75

#3

A B
C D
Male(s) - AC,BD
Female(s) - AC,BC
1
C

Output 0.125

\$\endgroup\$
  • 1
    \$\begingroup\$ "Once two/three answers are posted, I'll use the same testcases in all of them to see which of them are faulty" You should have a way to verify answers without using other answers. \$\endgroup\$ – FryAmTheEggman Dec 1 '15 at 17:35
  • \$\begingroup\$ @FryAmTheEggman I am abandoning this Q, anyone else is free to post it themselves. \$\endgroup\$ – ghosts_in_the_code Dec 2 '15 at 9:47
0
\$\begingroup\$

Cops and Robbers - Find the Formula

Cops will write a function that takes numerical inputs and produces numerical outputs (note - outputs can be any base and may contain letters). They will post the language, the number of bytes it takes to write the code (up to 128), rounded up to the nearest power of 2, as well as a minimum of 2 test cases. The robbers will try to write a program that takes the same numerical inputs as the test cases and produces identical outputs.

Note - PRNG's, hashing, and other forms of encryption are not allowed.

Scoring

Cops (if safe)

The floor of the product of:

  • 128 divided by the power of two rounded up for the bytes
  • The natural logarithm of the number of test cases

If cracked, -10 points.

Robbers

The floor of the quotient of

  • Half the number rounded up to by the cops
  • The natural logarithm of the number of test cases
\$\endgroup\$
  • \$\begingroup\$ Say I have a function f(x) that returns x when x<2 and 3*x ᴏtherwise. Would the robber's function only have to match the given test cases, or have to match all test cases? \$\endgroup\$ – Conor O'Brien Nov 27 '15 at 3:06
  • \$\begingroup\$ @CᴏɴᴏʀO'Bʀɪᴇɴ The given test cases only. \$\endgroup\$ – Arcturus Nov 27 '15 at 3:16
  • \$\begingroup\$ Is there a maximum of test cases? \$\endgroup\$ – Conor O'Brien Nov 27 '15 at 3:24
  • \$\begingroup\$ @CᴏɴᴏʀO'Bʀɪᴇɴ I'm not sure if there should be. If there were, I'd say maybe 10 or 12. \$\endgroup\$ – Arcturus Nov 27 '15 at 3:25
  • \$\begingroup\$ I think the scoring algorithm might be a bit complex. \$\endgroup\$ – Conor O'Brien Nov 27 '15 at 3:41
  • \$\begingroup\$ @CᴏɴᴏʀO'Bʀɪᴇɴ I want to do something that awards points depending on the number of test cases because that makes it more likely that the robber found the intended solution and is "more" right. \$\endgroup\$ – Arcturus Nov 27 '15 at 5:03
  • 2
    \$\begingroup\$ The cops-and-robbers lesson which everyone should have learnt by now is that built-in crypto functions should be banned because otherwise the cops have an easy time. \$\endgroup\$ – Peter Taylor Nov 27 '15 at 13:49
  • 1
    \$\begingroup\$ ^ That should include hashing and PRNGs. Although it's really hard to rule them out conclusively. My personal goal is still to come up with more CnRs that aren't susceptible to stuff like that in the first place (like my Programming Language Quiz). \$\endgroup\$ – Martin Ender Nov 27 '15 at 14:00
  • \$\begingroup\$ @MartinBüttner Given that I've explicitly disallowed hashing, PRNGs, and encryption, what do you think of this challenge? \$\endgroup\$ – Arcturus Nov 27 '15 at 22:15
  • \$\begingroup\$ @Eridan It's still susceptible to arbitrary base conversions or expmod (just check out any CnR-submission by Dennis to see some examples). People can just throw together a quasi-random program in a golfing-language without having to understand it and just run some numbers through it to generate test cases. \$\endgroup\$ – Martin Ender Nov 27 '15 at 22:36
  • \$\begingroup\$ @MartinBüttner I didn't realize those were bad for CnR challenges (I even mentioned base conversion above). Is there a specific way I could describe methods like those to disallow them? \$\endgroup\$ – Arcturus Nov 27 '15 at 22:50
  • \$\begingroup\$ @Eridan none I can think of. That's why I meant that this is an inherent problem of any CnR that lets participant choose what their program does. In CnRs where the programs need to solve a specific task, this is not such a big issue, because the cops actually need to find a convoluted but working implementation themselves. \$\endgroup\$ – Martin Ender Nov 27 '15 at 23:07
  • \$\begingroup\$ Even with crypto banned, numerical functions make for boring CnR challenges since it's much more likely to be about finding parameters rather than guessing the structure of the code. \$\endgroup\$ – xnor Nov 28 '15 at 9:57
  • 1
    \$\begingroup\$ A problem: Anyone can just write an interpolating polynomial. \$\endgroup\$ – LegionMammal978 Nov 28 '15 at 13:49
0
\$\begingroup\$

Quiddler

Quiddler is a card game where you try to create words from letter cards drawn from a deck. A word is defined as being more than 2 cards in length. Sometimes letters are combined on cards in this game, however that will not be the case in this challenge.

Your mission is to write a program which creates words from the letters read in on standard input. Your dictionary of words is the words file on any standard unix system. You may assume that all strings this file is all lowercase.

Input

The string of letters you can use to create words is read in on standard input. This string will be all lowercase, and will not have any spaces in it.

Valid examples are:

actlj
jactl
ljdkj
jjabc

Invalid are:

jklKLJKKJLKUIU
klj kljklj djkas;

Output

The list of all possible results from said string each string. Remember you can produce multiple words in the same answer.

Examples of valid output include. Please remember that I came up with these off the top of my head, and may not be complete. Input is left aligned and the output is presented as the indented lines. The -> is for your benefit.

tacb  -> 
         cat
         act
         bat
         tab

fivquedrr ->
         five qud
         quid five
         river
         quiver

The order of the solutions output does not need to be in any specific order.

The environment

This program must run in a standard UNIX-like environment. This means that you may use any standard shell (bash, ksh, csh, zsh, fish), and you have access to all the standard tools. This challenge is restricted to the shell scripting languages.

The path to the dictionary file in the environment variable, DICT, the path to the file should not be in any valid solution. Use $DICT as the path to the dictionary. This is included so that you can provide testing instructions for your program.

Winner

The winner is the one with the fewest bytes of code that produces the correct output.

\$\endgroup\$
  • \$\begingroup\$ In the example output, I'm not sure why for the first input the output is newline-separated, but for the second it's space-separated. I also don't understand the second paragraph in the section "The environment". \$\endgroup\$ – Peter Taylor Nov 27 '15 at 21:30
  • \$\begingroup\$ @PeterTaylor In quiddler you can have multiple words per possible solution. I'll add a second example to demo. \$\endgroup\$ – HSchmale Nov 27 '15 at 21:53
  • \$\begingroup\$ So is this basically a variant on Countdown where the dictionary is amplified by including its Cartesian power? \$\endgroup\$ – Peter Taylor Nov 28 '15 at 8:08
  • \$\begingroup\$ @PeterTaylor: Pretty much, except I did not know that existed. Also, for each answer you can only use each answer once. \$\endgroup\$ – HSchmale Nov 28 '15 at 16:43
0
\$\begingroup\$

Ancient Language Translator

<insert a silly story here>

Task:

Write a program that takes an English sentence and translates it into the Ancient Language. You have to implement at least 42 words. For the purpose of this challenge, you do not have to care about special rules such as "(may be shortened to al when used as a prefix, as in albitr)".

Input:

An English sentence.

Output:

A translated version of the input, simply replace the English words with the Ancient ones.

Examples:

To be added.

Scoring:

Suggestions?

\$\endgroup\$
  • 2
    \$\begingroup\$ This might be considered as too broad as there is no specific words to implement. For scoring a code-challenge might work with the score being something like the sum of the length of all words implemented. code-golf might also work. Kind of related challenge. The title is also possibly misleading, so I'd suggest putting "Ancient Language" in quotes \$\endgroup\$ – Downgoat Nov 29 '15 at 16:55
  • \$\begingroup\$ I think this would be uninteresting just because it's just replacement, not actual translation. \$\endgroup\$ – cat Nov 30 '15 at 3:07
  • \$\begingroup\$ @sysreq Translating English into the "Ancient Language" is just replacement as far as I know... \$\endgroup\$ – Stefnotch Nov 30 '15 at 17:24
  • \$\begingroup\$ @Downgoat Oh, ok! So, what words should have to be included? A selection of) the most common words: en.wikipedia.org/wiki/Most_common_words_in_English \$\endgroup\$ – Stefnotch Nov 30 '15 at 17:26
0
\$\begingroup\$

Nested Header List

The goal of this challenge is to complete a list of consecutive nested header numbers when given a start and an end. When given 1.1.1 and 1.1.5 you should generate 1.1.1, 1.1.2, 1.1.3, 1.1.4, 1.1.5

Specific Rules

  1. Your entry must take in a start, end, and multiple optional range parameters. Parameters can be taken form STDIN (or nearest equivalent) or a file.
  2. Your entry may assume valid input
  3. Input will be of the following format:
    1. start and end will be strings of . delimited integers of the same length
    2. start and end will have three segments; (1) set values, (2) iterator, (3) trailing values.
      • The iterator is the first value which differs between start and end.
      • The set values are the values before the iterator. These values never change
      • The trailing values are the values after the iterator. These values iterate up as determined by the range parameter(s). All trailing values will be 1.
    3. range will be a list of integers with a length corresponding to the number of trailing values. When there are no trailing values, range is not specified. The value of range corresponding to each trailing value determines the inclusive upper bound which that entry iterates to.
  4. Output will be to STDOUT (or closest alternative) and will show each value separated by at least one delimiter. Delimiter can by any character or string of characters, but it must be consistent. Output must be sorted correctly

Examples

start = '1.1.5.1', end = '1.1.6.1', range = [5]
Output: 1.1.5.1, 1.1.5.2, 1.1.5.3, 1.1.5.4, 1.1.5.5, 1.1.6.1
                                                  ^
                                                  previous value is iterated
                                                  only when iterating value
                                                  limit set by range


start = '1.1.5.1', end = '1.1.7.1', range = [5]
Output: 1.1.5.1, 1.1.5.2, 1.1.5.3, 1.1.5.4, 1.1.5.5, 1.1.6.1,
        1.1.6.1, 1.1.6.2, 1.1.6.3, 1.1.6.4, 1.1.6.5, 1.1.7.1

start = '1.5.1.1', end = '1.6.1.1', range = [5,2]
Output: 1.5.1.1, 1.5.1.2, 1.5.2.1, 1.5.2.2, 1.5.3.1, 1.5.3.2, 
        1.5.4.1, 1.5.4.2, 1.5.5.1, 1.5.5.2, 1.6.1.1

This is code golf so shortest code by bytes wins.

Bonuses

  1. Allow trailing values to be values other than 1 in end parameter - 12.5% off
  2. Handle incorrect number of values in range parameter - 12.5% off
  3. Handle end less than start by producing list in reverse - 50% off
\$\endgroup\$
0
\$\begingroup\$

Count the Connect Four Positions

Connect Four is a two-player game on a rectangular board. The board is m spaces wide and n spaces tall, and players alternate placing pieces in columns. A placed piece always fills the lowest empty space in a column, and a player may not move in a full column. In the standard game, m=7 and n=6.

The game ends when one player completes a row of four pieces vertically, horizontally, or diagonally, or all m columns are full. The edges of the board do not wrap.

Challenge

Write a program or function to determine the number of distinct, legal m by n Connect Four boards after p plies. (A ply is one move by one player.) A legal position is one reachable from the empty board through a sequence of moves in which no player had already won. (A position in which one player has just won is legal.)

Rules

You may assume that 0<=p<=m*n, m<=8 and n<=8.

As usual, hardcoding is not allowed.

Your code should be at most 1024 bytes in length, and use at most 16 GB of memory.

Related: Determine winner of Connect 4

Test cases

[need to add; include OEIS]

Relevant links:

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

Compile from Brainfuck

The professors at Brainfuck University realized their jobs are horrible, because all they do is discuss quantum mechanics using Brainfuck, so they decided to take their programs and compile them to a better language. Because of the randomness of quantum particles, their program needs to be small so it has a smaller chance of being disrupted in the Higgs Field.

Your task is to get a Brainfuck program from any input and output that program transcompiled into another language. Here is an example:

++-->><<

Compiles to the C program:

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

int main(int argc, char **argv) {
    unsigned char *cell = calloc(30000, 1);
    unsigned char *cells = cell;
    if (!cell) {
        fprintf(stderr, "Error allocating memory.\n");
        return 1;
    }
        //actual program
        ++*cell;
        ++*cell;
        --*cell;
        --*cell;
        --cell;
        --cell;
        ++cell;
        ++cell;

        free(cells);
        return 0;
}

Score

Your score is the size of your program added to the size of the output.

Bonuses

\$\endgroup\$
  • 3
    \$\begingroup\$ Dupe \$\endgroup\$ – Mego Dec 5 '15 at 9:55
0
\$\begingroup\$

Logic Puzzle Solver/Inference Engine

Your goal is to take the clues and other facts given in a grade-school logic grid puzzle such as these and solve the puzzle. To keep things simple, your program will only solve specific logic problems about which it can make the assumptions you wish to hard-code in, but the program need not perform any checks to see if those assumptions can be made.

You may not use:

  • A declarative language
  • Any function provided - by an external dependency - for the solving of a logic puzzle.

Input

Your program will take input from the command line. After gathering assumptions, the program will ask for facts written as such:

subject.verb object

for all true facts. For false facts:

!subject.verb object

Examples: If Chad bought donuts,

Chad.bought donuts

If he didn't:

!Chad.bought donuts.

If Nancy's last name isn't Wesley,

!Nancy.is Wesley.

Output

Your program will output its conclusions as such:

subject verb object.

So, if your program determines that Chad bought donuts and Nancy's last name is Wesley, then it will output:

Chad bought donuts.

Nancy's last name is Wesley.
\$\endgroup\$
  • 3
    \$\begingroup\$ The "these" link goes to a login page. I'm not going to create an account on some random site just to find out what the spec is. \$\endgroup\$ – Peter Taylor Dec 15 '15 at 22:24
  • \$\begingroup\$ "You may not use a declarative language" :-( \$\endgroup\$ – Fatalize Dec 16 '15 at 12:59
  • \$\begingroup\$ Does "is" always refer to someone's last name? If not, how can our code know the difference between Nancy.is Wesley and Nancy.is chef? \$\endgroup\$ – Luke Dec 16 '15 at 14:49
0
\$\begingroup\$

New user to Programming Puzzles!

Spades CHALLENGE!!!

I would like a king of the hill challenge for bots playing the game of spades. Spades is a card game. The rules are shown on wikipedia.

Scoring rules:

  • Nils allowed, with 50 points for completion (not 100). -50 for losing.
  • 10 points a hand, with sandbagging allowed.
  • Partnership Playing
  • Sum of all four players hands cannot equal 13!

Winner is first to 500 points. The bot will be paired with all other bots entered into the competition. The pair of winners will be crowned with +10 meta-points (Mpoints), losers will get -1 Mpoints. Whoever has the most Mpoints wins - ties based upon sum of points earned in the games.

Gameplay:

  • The bot with the lowest Mpoints bids first. Bidding proceeds from down until reaching 4th slot, then goes back to first slot and continues. Play starts with this player.
  • The bot will be given a string of cards - AS for Ace of Spades, JC for Jack of Clubs, 2D for 2 of Diamonds, 8H for 8 of hearts, randomly dealt from a single 52-card deck. Each will be comma separated: AS,JC,2D,8H,4C,5S,8D,3D,3S,JS,10S
  • The bot will get the bids from the other bots before making the bid.
  • Upon winning a hand, the bot gets to continue making plays until someone else wins the hand.
  • Hands are scored at the end using the scoring rules. If a team's score is less than 500, gameplay continues with a new hand.

Unfortunately, I do not know how to setup the servers or any of that stuff. I just think the challenge will be interesting. If anyone can help with that, run with it. I like to watch these challenges unfold - but I'm too much of an engineer and not enough of a programmer to make these kinds of programming happen.

\$\endgroup\$
  • \$\begingroup\$ You should fully list out the rules in the body of the question - it's considered poor form for challenges to require exterior resources to be fully understood. \$\endgroup\$ – Mego Dec 22 '15 at 22:56
0
\$\begingroup\$

I was thinking about a challenge on wrapping time.

I am a member here for 34 days now. I would have expected for the date to wrap to 1 month.

Rules:

  • starting with hours from the joining date to now.

  • first wrapping happens when you go over 24 hours, the count will be in days now.

  • second wrapping happens after reaching 30 or 31 days, you can decide, to months.

  • third wrapping really wraps when a year is reached, it shall be displayed as i.e. 2 years 3 month.

  • round to neares full unit, i.e. 43 days = 1 month, 50 days = 2 month

  • take either a build in function to get the current time or hardcode it to ´2015-12-19-11´ <- time when challenge will be posted. If hardcoding it is shorter you may take the bytecount from the hardcoded version.

  • Dates after the current or hardcoded date can do whatever.

Input

The joining date and hour like ´YYYY-MM-DD-HH´ the delimeter does not have to be a - choose whatever you like.

Output

The time according to the rules above.

Example:

In: 2015-12-10
Out: 9 Days

In: 2015-10-28
Out: 2 Month
\$\endgroup\$
  • \$\begingroup\$ I believe I saw a challenge about wrapping 24-hour time that may be related, but not a duplicate. Also, what date are we calculating the difference from? \$\endgroup\$ – ASCIIThenANSI Dec 18 '15 at 17:05
  • \$\begingroup\$ that would be the date right now or a set date if no build in is available \$\endgroup\$ – Eumel Dec 19 '15 at 8:19
  • \$\begingroup\$ I think it should be either a built-in date or another date given from input for all languages, to make things fair. \$\endgroup\$ – ASCIIThenANSI Dec 19 '15 at 16:02
  • \$\begingroup\$ I wanted it to be non input, how would you suggest doing that? \$\endgroup\$ – Eumel Dec 19 '15 at 20:01
  • \$\begingroup\$ Use a built-in date such as 01-01-2015 (or 01-01-2000, depending on what the date range should be). The program should not be required to accept dates before that. \$\endgroup\$ – ASCIIThenANSI Dec 20 '15 at 21:14
0
\$\begingroup\$

Browser identifier

There are three major browsers at the moment, Internet Explorer, Google Chrome and Firefox. Sometimes, the JavaScript engines inside of these browsers work a bit differently, and that can break some applications. Therefore, we need a way to identify what browser the user is currently using!

Your answer should be a JavaScript program or function, that when run on the latest version of a browser, should output a string representing that browser. The string outputed could be anything, as long as it stays the same every time you run it. Output should go to a HTML paragraph with id O, console.log, or as return value.

Please put your answer in a snippet, along with <p id="o"></p> in the HTML section if your answer uses it.

(scoreboard snippet goes here)

\$\endgroup\$
  • 1
    \$\begingroup\$ I believe Javascript has a builtin for this. It may be best to forbid using it. \$\endgroup\$ – SuperJedi224 Dec 22 '15 at 17:34
  • \$\begingroup\$ @SuperJedi224 Well, I did some searching before, and I found this thread on SO, and the highest voted answer was a big mess, and no answer was very short and reliable. There is this other thread, and it has some that could be golfed a bit, but there isn't really one function / builtin that checks the browser. \$\endgroup\$ – Loovjo Dec 23 '15 at 2:56
  • \$\begingroup\$ You might need to freeze the version numbers of the 3 browsers, or else require that answers specify version numbers. \$\endgroup\$ – trichoplax Dec 29 '15 at 15:54
0
\$\begingroup\$

Parse a tree for pruning

Windows supplies users with tree: a neat little tool that converts a directory tree to ASCII-CP437 art. It's a very human-readable format. However, it's a bit useless if you want the directory tree of an entire drive, or even just the Windows folder, as it's very hard to prune the parts you don't want. Hence this challenge.

Task

Your task is to produce a function or program that will convert the tree from one or both of the input formats into one or more of the output formats. The smaller your code, the more of a head start you have.

Input

There are two types of input that you might be given:

CP437

This is the default.

Folder PATH listing for volume Main Drive
Volume serial number is 00F3-F586
C:\WINDOWS
│   explorer.exe
│   notepad.exe
│   virus.dll
│   WLXPGSS.SCR
│   write.exe
│   
├───Boot
│   │   BootDebuggerFiles.ini
│   │   
│   ├───DVD
│   │       your.txt
│   │       
│   ├───EFI
│   │       pc.txt
│   │       
│   ├───Fonts
│   │       has.txt
│   │       
│   ├───PCAT
│   │       been.txt
│   │       
│   └───Resources
│           wrecked.txt
│           
├───System
└───System32
        cmd.exe
        conhost.exe
        winlogon.cmd
        winlogon.exe

ASCII

This will be easier to parse for many languages.

Folder PATH listing for volume Main Drive
Volume serial number is 00F3-F586
C:\WINDOWS
|   explorer.exe
|   notepad.exe
|   virus.dll
|   WLXPGSS.SCR
|   write.exe
|   
+---Boot
|   |   BootDebuggerFiles.ini
|   |   
|   +---DVD
|   |       your.txt
|   |       
|   +---EFI
|   |       pc.txt
|   |       
|   +---Fonts
|   |       has.txt
|   |       
|   +---PCAT
|   |       been.txt
|   |       
|   \---Resources
|           wrecked.txt
|           
+---System
\---System32
        cmd.exe
        conhost.exe
        winlogon.cmd
        winlogon.exe

Output

There are several possible types of output you can return, each suited to a different type of language.

Array / List hierarchy of strings

The first element of each array / list is the name, the rest are the contents. Files should be represented by strings, empty folders should be represented by a single-length array containing one string. Note: This should be returned from a function as an array / list, not printed as a string.

["C:\WINDOWS", "explorer.exe", "notepad.exe", "virus.dll", "WLXPGSS.SCR", "write.exe", ["Boot", "BootDebuggerFiles.ini", ["DVD", "your.txt"], ["EFI", "pc.txt"], ["Fonts", "has.txt"], ["PCAT", "been.txt"], ["Resources", "wrecked.txt"]], ["System"], ["System32", "cmd.exe", "conhost.exe", "winlogon.cmd", "winlogon.exe"]]

Object / Dictionary

Similar to array / list, but a little more intuitive. Folders should have the value of their contents as another object / dictionary. Files should have the value "FILE".

{"C:\WINDOWS":{"explorer.exe":"FILE","notepad.exe":"FILE","virus.dll":"FILE","WLXPGSS.SCR":"FILE","write.exe":"FILE","Boot":{"BootDebuggerFiles.ini":"FILE","DVD":{"your.txt":"FILE"},"EFI":{"pc.txt":"FILE"},"Fonts":{"has.txt":"FILE"} [...] } [...] } [...] }

Lisp-style string

Similar to array / list, where the head of the list is the directory name and the tail is the contents. An empty directory is a list with no tail, and a file is a string.

No WAY am I putting an example. No way. I've spent half the time on this question creating the examples. No way. Ok, maybe later.

Bonus

If you satisfy none of these bonuses, your submission is still valid. But its score shall infinite, so it is non-competitive.
These bonuses are to multiply your score by. Bonuses stack by multiplication. These bonuses must all be achieved consistently to be awarded.

  • 100% Allow at least one input mode and output mode
  • 50% Allow both input modes
  • 90% Output in exactly two ways
  • 50% Output in one of two ways depending on parameters
  • 80% Output in exactly three ways
  • 25% Output in one of three ways depending on parameters
\$\endgroup\$
0
\$\begingroup\$

Identifying spies in "Resistance"

This is still very rough, but I think it has the makings of an interesting challenge. Please help me improve it. What do I need to add? What do I need clarify?

Resistance is a party game that pits "resistance members" against "imperial spies" on a series of missions. A very important aspect of the game is that the resistance members do not know who the spies are, whereas the spies do know who is who.

How the game works

The relevant details of the game will be added here. For now, just check the Wikipedia page linked in the title.

Challenge

your challenge is to write a program that takes as input the details of every round and outputs who it thinks is a spy after each round. There are 5 rounds (missions) in a game of resistance, so the program/function will take in all the data for the first round, which includes

  1. Each proposed team to go on the mission
  2. Each public vote following each proposal
  3. The final team to go on the mission
  4. The outcome of the mission (i.e. how many passes and how many fails)

It will then output who it thinks is a spy. It will then do the same for each subsequent round.

Important Details

We will be playing resistance for (6?) people, A, B, C, D, E, and F.

Input format is flexible. It may be done round by round or all at once. However, since ach submission is outputting something for each of the five rounds, the submission may not use information from future rounds (if all information is given at once) in judging the current round.

Here is an example of possible input format:

Since the first mission requires two people, and person A is the first mission planner, the only thing input would be two letters in {A,B,C,D,E,F} indicating his selection. Then the votes of each person, in order, would be input. This continues until a mission team is accepted. Then the votes given on the mission would be input, in no/any particular order. The program would then output the letters of the two people it thinks are spies (there are 2 spies in a 6 person game). Here is an example

A B              # A selects A and B for first mission
P P P F F F      # Everyone votes, mission team is not accepted (lacks majority pass)
B F              # B selects B and F for first mission
P P P P P F      # Mission team is accepted (majority pass)
P F              # Mission fails (there is at least one fail vote). Note that the order does not matter here. 

The bot would then output two people, the people it thinks are most likely to be the spies based on all the information it has up to this point.

B F              # Any two person subset is acceptable

Input then continues for the next 4 rounds, until the game is over.

Scoring

I will write several hundred test cases (from actual games played online). Then each output will be scored in the following way:

  • 1 point for each correctly guessed spy.
  • 1 point for guessing both spies correctly.

The submission's total score will be the sum of all scores on all rounds in all games. The program will never be told who is a spy (unless it is used to self-score and does not factor into the actual guessing) but this information will be available with the test cases for scoring purposes.

Tie break is code golf.


Meta: I think I'm going to remove output after the first round, because very rarely do people ever fail the first mission. So it will likely just be pure chance.

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

Nth Regex

This challenge('s explanation) is simple: given a number n and a regex r, output the nth string that matches r!

The regex r uses the syntax used in Python, described here. The regex will be for the whole string, meaning the regex will be implicitly wrapped in ^$.

The only valid strings are printable ASCII characters, and they count up like base 95 (ASCII codes 32-126).

To prevent people from brute-forcing it, I was thinking of making it .

\$\endgroup\$
  • 1
    \$\begingroup\$ I still think you mean "bijective base 95". otherwise, there are no strings with leading spaces (because if count up in base 10, there are no numbers with leading zeroes). \$\endgroup\$ – Martin Ender Dec 29 '15 at 14:09
  • 4
    \$\begingroup\$ I'm not a fan of using a specific real-world flavour, because that gives an advantage to Python over all other languages. I also think it contains way too many features to be fun to tackle (which don't really add anything interesting to the challenge). I think the challenge would be interesting and hard enough for a simplified regex flavour containing only simple quantifiers, alternation and character classes. \$\endgroup\$ – Martin Ender Dec 29 '15 at 14:11
  • \$\begingroup\$ I'm quite sure that some regexes are hard to solve. codegolf.stackexchange.com/questions/39829/… \$\endgroup\$ – Element118 Dec 29 '15 at 15:54
  • \$\begingroup\$ I absolutely don't get the challenge, any example input/output ? \$\endgroup\$ – Tensibai Dec 30 '15 at 14:31
  • \$\begingroup\$ Do you mean nth string lexicographically? \$\endgroup\$ – xnor Dec 30 '15 at 18:45
0
\$\begingroup\$

Robots on ice

Part 1 - The basic

You are helping a robot R on an iced island. R can go up/down/left/right. But since the island is made of ice, it cannot move only 1 square at a time, but instead moves in straight line. Your task is to help R reach G.

Input

The input (file, stdin, input, whatever suits you) is an n×m matrice with the following characters:

  • R The robot
  • G The goal
  • # An obstacle that stops the robot
  • Ice

The island is surrounded by a wall: the edges of the matrice always consist of #.

Output

A list of instructions consisting of U/D/L/R, corresponding to up/down/left/right.

The list should be the shortest possible. The distance traveled by the robot doesn't count.

The output should be the map with the instructions on it, with each instruction at the right coordinates. Each of RG# should be displayed if not overriden by an instruction (that will always be the case for R)

Example

Input:

##########
# #      #
#        #
#  G #   #
#        #
#    R#  #
#        #
##########

Output: Since D,R,U,L,D is one possible solution, the output should be:

##########
# #D    L#
#        #
#  G #   #
#        #
#    D#  #
#    R  U#
##########

Another solution, U,R,U,L,D, should be output as:

##########
# #D    L#
#        #
#  G #   #
#    R  U#
#    U#  #
#        #
##########

Input:

####################
###R             ###
#  ######          #
#      #####       #
##                G#
###              ###
####################

Output:

####################
###R            D###
#RD######          #
#U L   #####       #
##R               G#
###U            L###
####################

You can assume that the puzzle always has at least 1 solution

Part 2 - New options

The pitch is the same, but new characters can be displayed:

Input

The input (file, stdin, input, whatever suits you) is an n×m matrice with the following characters:

  • R The robot
  • G The goal
  • # An obstacle that stops the robot
  • Ice
  • W Some water. Robot doesn’t like water
  • B a Box. Robot can push the box 1 square at a time, in front of him (not on the side), if the next square is . It cannot be pushed into the water, through the goal… Robot cannot push 2 boxes at once. When pushing, the robot stays in place.
  • 1 a numbered teleportation door. Always in pair. When entering a teleportation door, Robot will continue sliding in the same direction through the other door. Can be used more than 1 time.

The island will this time be surrounded by water.

Output

A list of instructions consisting of U/D/L/R, corresponding to up/down/left/right.

The list should be the shortest possible. The distance traveled by the robot doesn't count.

This time the output won't be displayed on the map, but on stdout. The format doesn't matter:

UDRL

or

U
D
R
L

are accepted

Example

Input:

WWWWWWWWWW
W W      W
W        W
W  G 1   W
W        W
W    1R  W
W        W
WWWWWWWWWW

Output:

L

Input:

WWWWWWWWWW
W W      W
W    #   W
W  G     W
W        W
W    BR  W
W        W
WWWWWWWWWW

Output:

LLUL

The first L moves the box (but not the Robot) 1 square:

WWWWWWWWWW
W W      W
W    #   W
W  G     W
W        W
W   B R  W
W        W
WWWWWWWWWW

Input:

WWWWWWWWWWWWW
W         # W
W G 2       W
W           W
W   B 1     W
W#2         W
W   # 1R   #W
W          #W
W    #     #W
WWWWWWWWWWWWW

Output:

L #entering teleportation 1
L #pushing the box to the left
L #going to the box
U #entering teleportation 2

The solution RULU is also valid

Input:

WWWWWWWWWWWWW
W #         W
W     #     W
W#   1      W
W           W
W           W
W    1 R    W
W           W
W    G      W
WWWWWWWWWWWWW

Output:

L #entering teleportation 1
U #going to the wall
R #going to the wall
D #entering teleportation 1

In this situations, Robot cannot moves to the left:

W  GBR   W

W  #BR   W

W  BBR   W

W  WBR   W

W    R   W

You can assume that the puzzle always has at least 1 solution

Part 3 - With help

Same as part 2 but with others robots:

Input

The input (file, stdin, input, whatever suits you) is an n×m matrice with the following characters:

  • R The robot
  • G The goal
  • # An obstacle that stops the robot
  • Ice
  • W Some water. Robot doesn’t like water
  • B a Box. Robot can push the box 1 square at a time, in front of him (not on the side), if the next square is . It cannot be pushed into the water, through the goal… Robot cannot push 2 boxes at once. When pushing, the robot stays in place.
  • 1 a numbered teleportation door. Always in pair. When entering a teleportation door, Robot will continue sliding in the same direction through the other door. Can be used more than 1 time.
  • abcde up to 5 robots that can move the same as Robot. They cannot go through other robots, including R, and can pass through the Goal. They can be sacrified by going into the water. They can be used more than 1 time.

The island is surrounded by water.

Output

A list of instructions consisting of U/D/L/R, corresponding to up/down/left/right, prefixed by the name of the robot moving.

The list should be the shortest possible. The distance traveled by the robot doesn't count.

As usual, theformat doesn't matter:

a:UDR
R:LU

or

aU
aD
aR
RL
RU

are accepted

Example

Input:

WWWWWWWWWWWWWWWWWW
W        a     # W
W   G            W
W                W
W                W
W                W
W             R  W
W                W
W       #        W
W             #  W
W                W
WWWWWWWWWWWWWWWWWW

Output:

a:R
R:UL

The answer DLUL is valid but not the shortest

Input:

WWWWWWWWWWWWWWWWWW
W                W
W                W
W                W
W                W
W  G    a    R   W
W                W
W                W
W                W
W                W
W                W
WWWWWWWWWWWWWWWWWW

Output:

a:U
R:L

Input:

WWWWWWWWWWWWWWWWWW
W           #    W
W                W
W  #             W
W           G    W
W                W
W                W
W           b    W
W   R       a    W
W                W
W                W
WWWWWWWWWWWWWWWWWW

Output:

b:U
a:UL
R:UR

Input:

WWWWWWWWWWWWWWWWWW
W                W
W           #    W
W          B     W
W  #             W
W     G          W
W                W
W  #             W
W   e       R#   W
W                W
W           a    W
WWWWWWWWWWWWWWWWWW

Output:

e:R
R:U
a:UL
R:LLDLUR

Input:

WWWWWWWWWWWWWWWWWW
W                W
W         G #    W
W   b            W
W                W
W           a    W
W   c            W
W           #    W
W   R            W
W                W
W          #     W
WWWWWWWWWWWWWWWWWW

Output:

a:U
b:RD
a:D
C:RD
R:RU

Input:

WWWWWWWWWW
W    G   W
W aBbBR  W
WWWWWWWWWW

Output:

a:L
b:LL
R:LLU

In this situations, Robot and b cannot move to the left:

W  GaRb  W

W  #b#R  W

W aBbBR  W

You can assume that the puzzle always has at least 1 solution

Sandbox Questions

Has it been done before?

What do you think? Is it understandable? Should I do 3 separated challenges (and in the sandbox)? More, less? Which part needs more examples? What part is unclear?

I would like to go with shortest-code win. Should I use kolmogorov instead?

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

Everything about PI

Pi is the most popular transcedental number. As a result, pi has been thoroughly studied. This challenge is in spirit of 9-Hole challenge.

1. Digits of PI

Given n and k, output n'th digit after the decimal point in the base-k representation. For example, the 5th digit of PI base 10 is 9.

5 10
9
10 2
0
6 16
10

If the base is more than 10, output like in the last test case

More information : http://www.virtuescience.com/pi-in-other-bases.html

2. Continued fraction of PI

Given n, output n'th number in continued fraction of Pi.

5
292
7
1

3. Closest to PI

Given a positive integer d, output the integer n such that n/d is closest to pi. For example, 17/5 is closer to pi than any other n/5.

 5
 17
 7
 22
 21
 66

4. Closest to PI 2

Given a positive integer n, output the integer d such that n/d is closest to pi.

5
2
7
2
20
6

Restriction.

  1. You should not have any floating-number buildin, only integer, including PI constants.
  2. Standard loophole is disallowed.
  3. The program may be 4 program or a program that reads challenge number.

Sandbox Question

Originally, I have 5 challenge, 4 more required. Now, one of them is dupe. 5 more required.

\$\endgroup\$
  • \$\begingroup\$ This does look suspiciously like lot of questions rolled into one. +1 and you could split it up into loads of challenges. \$\endgroup\$ – wizzwizz4 Dec 30 '15 at 12:10
  • \$\begingroup\$ Also, you could add more clarification on what a "9-Hole challenge" is. \$\endgroup\$ – LegionMammal978 Dec 30 '15 at 12:12
  • \$\begingroup\$ @LegionMammal978 codegolf.stackexchange.com/q/16707/46245 \$\endgroup\$ – Akangka Dec 30 '15 at 12:38
  • \$\begingroup\$ The spirit is more than one challenge in one question. \$\endgroup\$ – Akangka Dec 30 '15 at 12:48
  • \$\begingroup\$ Are you looking for 4 more sub-challenges, or a catchy name for a 5 component question? \$\endgroup\$ – trichoplax Dec 30 '15 at 16:17
  • \$\begingroup\$ Quintessential pi question? \$\endgroup\$ – trichoplax Dec 30 '15 at 16:18
  • 2
    \$\begingroup\$ A. I believe that the "many small holes in one question" model is considered a failed experiment. B. I don't understand the spec for part 1 at all. Part 2 is inadequately specified. Part 3 is a dupe. Parts 4 and 5 look almost completely trivial (or completely trivial for languages with a pi built-in). \$\endgroup\$ – Peter Taylor Dec 30 '15 at 18:39
  • \$\begingroup\$ Added that pi build-in is not allowed \$\endgroup\$ – Akangka Dec 31 '15 at 4:08
  • \$\begingroup\$ What about getting pi via inverse trig? Complex logs? Evaluating integrals? Banning the built in value still lets languages express it via math, and it's tricky to draw the line. \$\endgroup\$ – xnor Dec 31 '15 at 5:16
  • 1
    \$\begingroup\$ Also, why does every question need to use pi? If you want a challenge about, say, rational approximations, you can use arbitrary inputs or square roots or anything all langs have access to roughly equally. \$\endgroup\$ – xnor Dec 31 '15 at 5:18
  • \$\begingroup\$ @xnor 1. trigonometry, log, etc. is useless without floating point number. And any uses of floating point number isn't allowed (Even if it just uses addition only). However, I am afraid of integrals, too. 2. Just because. \$\endgroup\$ – Akangka Dec 31 '15 at 5:52
  • \$\begingroup\$ In the revised version, I think that if these were posted separately then part 1 would be closed as a dupe of part 3. Also, part 2 is still inadequately specified. You need to at minimum explain the indexing convention, and ideally specify what a continued fraction is (since some answers may use generalised continued fractions and confuse people who aren't familiar with them). \$\endgroup\$ – Peter Taylor Dec 31 '15 at 11:12
  • \$\begingroup\$ @PeterTaylor I don't understand how part 1 is dupe of part 3. For part 2 I uses simple continued fraction and what is indexing convention? \$\endgroup\$ – Akangka Dec 31 '15 at 11:17
  • \$\begingroup\$ A. Part 3 says "Given d, find n such that (n-0.5)/d < pi < (n+0.5)/d". Part 1 is essentially (since there isn't a general Plouffe formula for all bases) "Given k and n, find b such that b / k^n < pi < (b+1) / k^n and then return b % k". The core problem is almost identical. B. It's not enough for you to know that you're using simple continued fractions: the question has to make it clear. The indexing convention is whether you count the initial 3 + ... as index 0 or 1. \$\endgroup\$ – Peter Taylor Dec 31 '15 at 11:34
  • \$\begingroup\$ @PeterTaylor A. The insight clears my mind. Thanks. I don't think as far as that. B. 1. But I don't know how to explain that. Please add yourself. \$\endgroup\$ – Akangka Dec 31 '15 at 11:43
0
\$\begingroup\$

How to print 2016 using only the number 2?

Print 2016 using only the digit 2 operators and native language built-in functions.

The objective is to

  • Output the integer 2016 without using any digits except 2.
  • no characters / strings literals are allowed, i.e. no tricks like ord('b')
  • The code that uses the least number of 2s in the code wins.

For example, in python, the following code uses 8 twos.:

>>> int(str(2**2*2) + str(2**2)) * int(str(2) + str(2**2))
2016

Or like this code, uses 13 twos:

>>> 2 ** 2 ** 2 * 2 ** 2 ** 2 * 2 * 2 * 2 - 2 ** 2 ** 2 * 2
2016
\$\endgroup\$
  • 3
    \$\begingroup\$ Can you use constants initialized to a certain value (like CJam's Z variable which defaults to 3)? \$\endgroup\$ – GamrCorps Dec 31 '15 at 19:42
  • 1
    \$\begingroup\$ What's the tiebreaker if multiple answers have the same number of 2s? \$\endgroup\$ – Doorknob Dec 31 '15 at 19:46
  • 6
    \$\begingroup\$ 1. Every language that has variables will have a score of at most 1, since you can just save the initial 2 in a variable. 2. There are many ways to produce numbers without using characters, strings or other numbers, like taking the length of a list, for example. That means a score of 0 is just as easy. \$\endgroup\$ – Dennis Dec 31 '15 at 19:47
  • \$\begingroup\$ I would suggest making the scoring system a normal code-golf challenge and disallowing date functions. \$\endgroup\$ – GamrCorps Dec 31 '15 at 19:55
  • \$\begingroup\$ I will make my original suggestion again: require that every function and operator take as input either a number consisting entirely of 2's in some base, or the output of some function or operator that obeys this rule. If you insist on your "least number of 2's metric" count 2's passed inside variables or in the outputs of functions as contributing to this count. \$\endgroup\$ – quintopia Dec 31 '15 at 21:15
  • \$\begingroup\$ What about such version: In repl environment produce value 2016 using only number 2, operators and math functions. No any other functions allowed. Code golf or code challenge. \$\endgroup\$ – Qwertiy Dec 31 '15 at 21:17
0
\$\begingroup\$

Growing Quine 2

Your task is to give program P1..P5 so that.

  1. For all k<5, length of Pk < length of Pk+1
  2. For all k<5, Pk outputs Pk+1
  3. For all k<=5, Pk is semi-pristine program. (Program that if any run on the source-code is deleted, will output different output)
  4. P5 return P1 sufficient times that the output will be longer than P5

Shortest P1 wins

\$\endgroup\$
  • \$\begingroup\$ By rule 4, do you mean if P1 is abc, then the output should be abcabcabc... for the minimum amount of repetitions that is longer than P5? can we output it more often that necessary? Also, I think rule 3 makes this incredibly hard. \$\endgroup\$ – Martin Ender Jan 1 '16 at 16:40
  • \$\begingroup\$ First, Yes. The rule 3 is to prevent the padding of source code with nop. Maybe I will change into different output to make this easier. \$\endgroup\$ – Akangka Jan 2 '16 at 0:50
  • \$\begingroup\$ I mean rule 4 can repeat more often than necessary \$\endgroup\$ – Akangka Jan 17 '16 at 1:22
0
\$\begingroup\$

Zipping double quine.

You must provide 2 program, A and B. Both are a quine and have same length.

If A and B is zipped each other(Both when A is zipped first, or B is zipped first), the result is also an quine.

Standard Loopholes is not allowed and standard quine rules apply.

Examples

If program A is ABCDEF and program B is GHIJKL then

slangi "ABCDEF"
ABCDEF
slangi "GHIJKL"
GHIJKL
slangi "AGBHCIDJEKFL"
AGBHCIDJEKFL
slangi "GAHBICJDKELF"
GAHBICJDKELF
\$\endgroup\$
  • \$\begingroup\$ Do all three quines have to use the same language? Are function quines allowed? \$\endgroup\$ – Dennis Jan 6 '16 at 17:03
  • \$\begingroup\$ @Dennis All three quine have to use same language. Function quines is allowed. \$\endgroup\$ – Akangka Jan 7 '16 at 7:57
0
\$\begingroup\$

War of Flatland

If you haven't read Flatland, please do so here. It is a must-read, for mathematical and non-mathematical alike.

Oh no. No no no! War has broken out in Flatland. Society has crumbled, and all the women and children are either hiding or dead1. It is total anarchy, kill or be killed. It is such conflict that the 4th dimensional people have erected indestructible borders to prevent the conflict spreading.

On the plus side, if you came out on top, you could rule (some of) the entire world!

Specifications

  • You can be a shape with three or more sides. (No women1, remember?)
  • All shapes are regular.
  • You can only see by sight. (No feeling; you'll be killed if you get close enough to do that!)
  • Everybody starts with 1 health.
  • You can hurt other people by stabbing one of their edges with a vertex.
  • The vertex of an n sided shape deals 1/n damage.
  • An n sided shape has 4n angles of vision (sensors evenly spaced around the shape which see the nearest point and return the distance to it).
  • An n sided shape can see 2n different distances (range [0,16))
  • People don't see themselves. (What good is sight if your body gets in the way?)
  • People are all the same size (radius).
  • People can see everything within 16 units of their centre point.
  • If your health is 0 or below, you are killed.
  • The world has borders.
  • You can rotate by a maximum of 15 degrees either direction, then move exactly 1 unit towards either of your vertices every turn.
  • Each shape's "radius" is 8 units.
  • Degrees are anticlockwise from 3 O'clock. The 0th sensor is at 3 O'clock relative to the shape's orientation.

1 This is not me being sexist. Read Flatland.

Sandbox Meta:

I am using the Sandbox as a public incubator. I will build up and work on the challenge until it is ready, then post it as a question. But it made more sense to let others see, comment on and help with this challenge's development.

The Specifications are probably not going to remain in this format once the Stack Snippet and actual code is up and running.
I am working on, and have got quite far with, a JavaScript class to let people write code. If anyone can write a code to do the boring rendering thing onto a HTML5 canvas, I would be grateful.

Stuff I plan to add:

  • A stack-snippet battlefield
  • A JavaScript class to let people write code
  • A web-socket system to let people make submissions in other languages
  • A system to pull submissions from answers (I'm no good at this sort of thing)
\$\endgroup\$
  • \$\begingroup\$ 1. What counts as stabbing an edge? (I can see the numerical issues involved in working out whether a contact is vertex-vertex or edge-vertex being quite hairy). 2. What does it mean that "an n sided shape has 4n angles of vision"? 3. How does movement work? \$\endgroup\$ – Peter Taylor Jan 3 '16 at 17:07
  • \$\begingroup\$ @PeterTaylor 1. I calculate line intersections on shapes with close enough centres, then I count the intersections and work out where the intersections are. 2. First, read up on how Flatlanders see distance. Distance is represented by a number. You have 4n numbers, evenly spaced around the shape. So a triangle will have 12 angles of vision. 3. You can rotate by a maximum of undecided degrees and move 1 unit towards either of your vertices every turn. \$\endgroup\$ – wizzwizz4 Jan 3 '16 at 17:21
  • \$\begingroup\$ The word distance occurs only 9 times in the text, and none of them seem to address how distance is perceived per se. \$\endgroup\$ – Peter Taylor Jan 3 '16 at 18:01
  • \$\begingroup\$ @PeterTaylor Part 1 Chapter 5 \$\endgroup\$ – wizzwizz4 Jan 3 '16 at 18:24
  • \$\begingroup\$ Why not just say that vision extends out to 16 units and that each movement is 1 unit? Other considerations: what prevents a player from repeatedly stabbing another one? If everyone moves the same distance in a turn, I don't see how escape is possible. Do people/bots choose how many sides they have? It seems to me like a triangle would be the best choice. The only downside is fewer sensors, but I don't think that's a particularly bad one. \$\endgroup\$ – El'endia Starman Jan 5 '16 at 7:42
  • \$\begingroup\$ @El'endiaStarman I've been trying to make higher shapes more balanced. And hopefully there will be a defined bouncing mechanism after stabbing. (Spinning like a saw however...) And yes, they choose. \$\endgroup\$ – wizzwizz4 Jan 5 '16 at 8:00
  • \$\begingroup\$ @El'endiaStarman what if you always start as a triangle, a vertex forms on a side whenever one gets stabbed there (like a bruise swelling up). Or, in other words, an n-gon becomes an n+1-gon when stabbed. Stabs don't do ANY damage other than this. You die when n exceeds some threshold. This seems self-balancing: The more vertices you have the more people you can poke at once and the sooner you can poke them (because you already have a vertex aimed at them). \$\endgroup\$ – quintopia Jan 7 '16 at 17:05
  • \$\begingroup\$ Another balancing possibility is making higher-sided shapes move faster. \$\endgroup\$ – quintopia Jan 7 '16 at 17:07
  • \$\begingroup\$ @quintopia But that is simply a balancing system, and is in no way derived from the book. (But will probably be used if nobody can think of another way to balance the higher shapes that is derived from the book). \$\endgroup\$ – wizzwizz4 Jan 7 '16 at 17:42
  • \$\begingroup\$ I was purposefully avoiding letting the content of the book influence my recommendations. It's more important that the game is fun than that it's thematic. \$\endgroup\$ – quintopia Jan 8 '16 at 16:19
  • \$\begingroup\$ @quintopia I suppose... But your speed idea would introduce the issue of how fast? Would it be logarithmic? Would there be a point where it is unrealistic to be able to kill a higher-sided shape because they can practically teleport? \$\endgroup\$ – wizzwizz4 Jan 8 '16 at 16:51
  • \$\begingroup\$ @quintopia And the n=>n+1 idea is a completely different challenge! \$\endgroup\$ – wizzwizz4 Jan 8 '16 at 16:52
0
\$\begingroup\$

Print Euler's number on its own graph

Print the first n characters of Euler's number (e, 2.718281828459...) on a 'graph' of e^n. For example, input 3 (the x and y-axis scales here are provided for reference, and need not be implemented in your program):

20 |         1
19 |
18 |
17 |
16 |
15 |
14 |
13 |
12 |
11 |
10 |
 9 |
 8 |
 7 |     7
 6 |
 5 |
 4 |
 3 | 2
 2 |
 1 |
 0 | - - - - - - -
     1   2   3
      digit #

In the example above, note that:

  • Three digits of Euler's number are presented
  • Each digit is shown at a height equal to e^n, where n is the digit number. 2, for example, is shown at height 3 because e^1 = 2.72, which we round up to 3. You may round up or down, see below.

Various other informational bits:

  • Rounding need not be implemented; 271 is acceptable output for input 3, as is 272.
  • You will always be provided with input >= 1 , and your input will never contain decimal places nor any characters other than 0-9.
  • You may round the y value up or down, I.e. e^3 = 20.0855 may be shown as y=20 or y=21.
  • Your graph must have higher y-values at the top and higher x-values to the right; it must have a positive slope
  • You may use any amount of horizontal spacing >= 1 between successive digits. In the example above, there are 3 spaces between successive digits. You just can't have digits stacked on top of eachother.
  • You are not required to print scales on the x or y axis.
  • Your input will always be <= 10.
  • You may hardcode the required digits if you so desire.
\$\endgroup\$
  • \$\begingroup\$ You should specify about trailing and leading whitespace, on each line and before and after the graph. \$\endgroup\$ – FryAmTheEggman Jan 14 '16 at 15:50
0
\$\begingroup\$

Print as many numbers as you can

A challenge where you have two occurrences of each ASCII character from 20 to 7E to write as many programs as you can to print single distinct integers (one integer per program). For example, you cannot have A and AA to print 10 and 1010 in CJam, respectively, as that is three occurrences of A.

Full programs are not required.

You get 1 point for each integer you print. In the case that two answers create the same number of integers, the tiebreaker is the answer that uses the fewest bytes to create the integers.

Is this a good idea for a challenge? Also, is it a dupe? I feel like I've seen it before but I'm not sure.

\$\endgroup\$
  • \$\begingroup\$ 1. TT is an odd example here, since it would print 10\n10 in Pyth. AA prints 1010 in CJam. 2. Are full programs required? Are leading zeroes allowed? Can the integers be negative? \$\endgroup\$ – Dennis Jan 8 '16 at 6:00
  • \$\begingroup\$ I'm a little confused by the scoring, would we get to pick our own integer? And in your example, would AA count for two points? If so I think most answers would be something like BC#D#E#F#{A}* in CJam, where they just output the number a million billion times in a loop. (Don't try this online..) \$\endgroup\$ – FryAmTheEggman Jan 8 '16 at 18:12
  • \$\begingroup\$ @FryAmTheEggman I added how it would be scored. The example you have would be I avoid anyways as it contains more than 2 # characters. \$\endgroup\$ – Arcturus Jan 8 '16 at 19:49
  • \$\begingroup\$ Sure, but that doesn't stop people from generating giant numbers in other ways, or even infinite loops. I think a better approach would be to count the total number of programs that print exactly the same number exactly once with the same restriction. I do think this is a neat idea, but I don't think optimizing for the largest numeric output is nearly as interesting. \$\endgroup\$ – FryAmTheEggman Jan 8 '16 at 20:16
  • \$\begingroup\$ @FryAmTheEggman The challenge isn't to optimize the largest number; it's to make the greatest quantity of numbers. \$\endgroup\$ – Arcturus Jan 8 '16 at 21:23
  • \$\begingroup\$ Yes, but they are really the same thing. If I can make a large number I can print a lot of numbers. \$\endgroup\$ – FryAmTheEggman Jan 8 '16 at 21:24
  • \$\begingroup\$ But can you make large numbers with multiple programs (remember that you can only print one integer at a time and only have 2 of each printable ASCII character to write all your programs)? \$\endgroup\$ – Arcturus Jan 8 '16 at 21:36
  • \$\begingroup\$ Ok, that's what I was asking about, if each program is limited to 1 point I think it's fine, that just didn't seem very clear to me, especially because of the AA example. \$\endgroup\$ – FryAmTheEggman Jan 8 '16 at 21:52
  • \$\begingroup\$ 1..99 in PowerShell will print a bunch of numbers (and similar in other languages). Is each program limited to only printing one? I think that's what you're intending, but it's not super-clear in your post. \$\endgroup\$ – AdmBorkBork Jan 8 '16 at 22:01
  • \$\begingroup\$ I'm confused. Can you give an example? And how about character outside 20 - 7E? \$\endgroup\$ – Akangka Jan 9 '16 at 2:21
0
\$\begingroup\$

Smallest Turing Complete Interpreter

Sandbox Notes

  • Has anything like this ever been done before?
  • Do you think this will be well received?
  • In my research I couldn't find a simple definition of what makes a language "Turing complete". What alterations or additions should I make to the language rules? I would prefer that the language in every answer was not exactly the same, but at the same time I want to keep the complexity as low as possible (while still being Turing complete) so that ideally one of the answers would become the world's smallest (non-eval) interpreter.
  • Are there any other loopholes I missed?

Let me know in the comments!


Your challenge is to make the smallest possible interpreter for a programming language.

What is the language we are interpreting?

You get to create the language! You can implement any instructions you like, however the language must be Turing complete. For the purposes of this challenge, your "Turing complete" language must be able to:

  • Store and retrieve an arbitrary amount of data in memory The amount must be theoretically infinite, but your interpreter only needs to handle a minimum of 64 kilobytes (256 ^ 0xffff distinct values). The format could be an array of numbers, a string, a very large integer (if the language of your interpreter supports 524288-bit integers :P ) or any other format that provides the same number of distinct values.
  • Loop conditionally The loop must also be able to alter the execution flow (if you implement a while loop that can only have one instruction in the body, it won't be able to affect anything outside of the while loop). This can be one command (eg: while A do { B C D }) or two (eg: if A then B and goto C) or any number that produces the same effect.
  • Print any ASCII character This includes code points 32 to 126 inclusive. Newline is not required but being able to print characters outside of this range is fine.

It does not need to take input. Any extra features are fine as long as it meets these requirements. The language does not have to be pleasant to use, but each of these requirements must be usable in the real world.

See the languages here for some inspiration...

Input

  • Your interpreter must take a single string containing the source code of a program in your language.
  • The input will always be a valid program. You do not need to handle endless loops, impossible instructions, etc.

Output

  • A single string containing the output of the program.
  • A single trailing newline is allowed, any other leading or trailing whitespace is not.

Rules

  • The only rule is that you cannot use eval (or equivalent) in your interpreter.
  • Your interpreter must be a full program, not just a function. Input and output must be from STDIN, STDOUT or their equivalents.
  • The interpreter and the specifications of your language must be posted in your answer. Make sure you include all details that prove the language is Turing complete!
  • Your language can be identical to an existing language or a language from another answer.

Remember...

This is . Your score is the number of bytes in the source code of your interpreter, so design your language to minimise this score.

Good luck!


Sample Answer

JavaScript (ES6), 148 bytes

s=prompt();o="";m=[];for(p=i=0;c=s[i];i++)v=m[p],+c?c-1?c-2?c-3?c-4?o+=String.fromCharCode(v):p++:p--:m[p]=~~v+1:m[p]=~~v-1:m[p]?i=m[p+1]:0;alert(o)

Language Specification

Memory is stored on an infinite tape. The pointer variable points to a position within this tape. The index variable holds the index of the current instruction in the source code being executed. Each instruction is a single-digit number. The numbers do the following:

  • 5 = print character ASCII code at pointer
  • 4 = increment pointer
  • 3 = decrement pointer
  • 2 = increment value at pointer
  • 1 = decrement value at pointer
  • 0 = if the value at pointer is non-zero, set index to the value at pointer + 1

Explanation

Using numbers instead of letters for the instructions means I can check with c-3 instead of c=="x".

s=prompt();
o="";
m=[];
for(p=i=0;c=s[i];i++)
  v=m[p],
  +c?
    c-1?
      c-2?
        c-3?
          c-4?
            o+=String.fromCharCode(v)
          :p++
        :p--
      :m[p]=~~v+1
    :m[p]=~~v-1
  :m[p]?i=m[p+1]:0;
alert(o)

Test

prompt = () => input.value;
alert = (output) => result.textContent = output;
var solution = _=>{ s=prompt();o="";m=[];for(p=i=0;c=s[i];i++)v=m[p],+c?c-1?c-2?c-3?c-4?o+=String.fromCharCode(v):p++:p--:m[p]=~~v+1:m[p]=~~v-1:m[p]?i=m[p+1]:0;alert(o) };
<textarea id="input" rows="5" cols="70">222222222222222222222222222222222222222222222222222222222222222222222222522222222222222222222222222222522222225522254222222222222222222222222222222222222222222225111111111111531111111111111111111111115222222222222222222222222522251111115111111115425</textarea><br />
<button onclick="solution()">Go</button>
<pre id="result"></pre>


Tags:

\$\endgroup\$
  • \$\begingroup\$ You ought to add that all submissions include a proof of TC-ness \$\endgroup\$ – quintopia Jan 9 '16 at 6:49
  • \$\begingroup\$ @quintopia Yes. I've been contemplating what the simplest way to prove turing-completeness is. At the moment the only way to check is by looking at their language specs and comparing them to the checklist in my question, but maybe there's a simple program that uses all these rules that I could require (or at least recommend) to be made and run in their language which proves Turing completeness... \$\endgroup\$ – user81655 Jan 9 '16 at 8:03
  • \$\begingroup\$ The only way to prove TC-ness that I know is to reduce a universal language to it. But you can let the submitter decide which language they want to reduce to it. \$\endgroup\$ – quintopia Jan 9 '16 at 8:07
  • 1
    \$\begingroup\$ 1. I would vote to close this as too broad. It essentially duplicates half of the interpreter tag. See in particular codegolf.stackexchange.com/q/40300/194 . 2. What makes a language TC is the ability to emulate a universal TM. This is often proven by proving ability to emulate another known-TC system and applying transitivity. 3. In "a minimum of 64 kilobytes (256 ^ 0xffff distinct values)", what is ^ and how does 256 ^ 0xffff relate to 64 kB? 4. Not all TC systems have an explicit concept of loop. \$\endgroup\$ – Peter Taylor Jan 9 '16 at 17:04
  • 1
    \$\begingroup\$ 5. Output in ASCII seems to directly contradict your stated intention to "keep the complexity as low as possible" and inspire "the world's smallest (non-eval) interpreter". 6. The restriction against eval seriously constrains some languages' ability to process input. \$\endgroup\$ – Peter Taylor Jan 9 '16 at 17:05
  • \$\begingroup\$ @PeterTaylor Yeah, the broadness of the challenge is my main concern. I'm not sure there is a way to fix this without changing the purpose of the challenge as well. Addressing your other points: 3. There are 256 to-the-power-of 0xffff different ways you can arrange the bits of a 64 kilobyte block of bits. I just worded it like this to illustrate that the memory can be stored in any way that produces the same effect (rather than enforcing a 16384 length array of 32-bit integers, etc). The wording could be improved. \$\endgroup\$ – user81655 Jan 10 '16 at 2:47
  • \$\begingroup\$ @PeterTaylor 4. I assumed that would be necessary. How would it compute a recursive algorithm without the execution jumping back to the start of the algorithm repeatedly? 5. True. It's purpose was to unify the output of the languages and simplify testing but it would probably be more work for some interpreter languages. 6. That was to prevent trivial answers like eval(input). I could make an exception for using eval to parse the input as a literal. \$\endgroup\$ – user81655 Jan 10 '16 at 2:47
0
\$\begingroup\$

Find my way

I wanted to propose a challenge that is code golf (shortest answer wins), but with more programming challenge than parsing and printing funky text. Let's see if it sticks.

You are given a maze map, such as this:

#################################################
##########                    ######  ##### 1 ###
####   ##   ######  ########  #####     ####  ###
##   ###   #######  ########   ######  ###    ###
## X  ##  ########  #####      ####   #####  ##  
#                      ##      ##    ##      ##  
###################   ####   #####   #   ##  ##  
###   #############  #####   ######  #  ##   ####
##   ###             ##      ##    ##   ##     ##
#   ##      ####     ##  #   #   #      ###    ##
#  ####              ##      #   #  #        ####
#   #####   ###    ####   #####  #  #############    
#  #####   #####  ####   ##  ##     #############
   ###             ##     #  #     ########      
   ##     ####    #####   ####     ########   ###
  ##     ###                ##        #####   ###
          #####################   #   #####      
#####       ##############  ##   ###    #########
##      #   ###     ######  ##    #   ###########
#########        #               ##########      
      ###   ###     ##   ##################      
      ###   ##########   ########################
#################################################

and you need to help the player 1 find the goal X. You can assume the following rules apply to the input map:

  • it is a n x m ASCII rectangle (i.e. n lines of m characters);
  • only the following characters are allowed: #, 1, X, (whitespace) and newline;
  • # represent walls (that can't be crossed), represent empty space (that can be crossed); you can go anywhere in the n x m rectangle but you can't leave it (it's not Pacman).

If the maze has a solution, you shall produce an output of the following form:

#################################################
##########DLLLLLLLLL          ######  ##### D ###
####   ## D ###### U########  #####     ####D ###
##   ### DL####### U########   ######  ###  D ###
## X  ## D######## U#####      ####   ##### D##  
#  ULLLLLL         UL  ##      ##    ##     D##  
################### U ####   #####   #   ## D##  
###   ############# U#####   ######  #  ##  D####
##   ###  RRRRRRRRRRU##      ##    ##   ##  D  ##
#   ##    U ####     ##  #   #   #DLLLL ### D  ##
#  ####   U          ##      #   #D # ULLLLLL####
#   ##### U ###    ####   #####  #D #############    
#  #####RRU#####  ####   ##  ##  DL #############
   ###  U          ##     #  #  DL ########      
   ##   U ####    #####   ####DLL  ########   ###
  ##RRRRU###                ##RRD     #####   ###
    ULLLLL##################### D #   #####      
#####    U  ##############  ##  D###    #########
##      #U  ### DLL ######  ##DLL #   ###########
#########ULLLLLLL#ULLLLLLLLLLLL  ##########      
      ###   ###     ##   ##################      
      ###   ##########   ########################
#################################################

where:

  • the letters U, R, D and L represent movements by 1 character to the, respectively, up, right, down and left;
  • the letter chain represent a valid path from the original 1 (which has been replaced by a direction character) and X.

If the maze has no solution, you should return void, NULL or anything equivalent.

Final rules:

  • this is code golf, so the shortest solution wins;
  • typical code-golf rules for input and output apply.
\$\endgroup\$
  • \$\begingroup\$ This is near enough to codegolf.stackexchange.com/questions/42707/can-maze-be-solved that I'd call it a duplicate \$\endgroup\$ – quintopia Jan 9 '16 at 18:18
  • \$\begingroup\$ Your solution is odd: It is not the shortest path. \$\endgroup\$ – Nathan Merrill Jan 10 '16 at 12:54
  • \$\begingroup\$ @NathanMerrill: that was to illustrate that producing an optimal solution wasn't required \$\endgroup\$ – Alexandre Halm Jan 10 '16 at 12:59
  • \$\begingroup\$ @quintopia: the example you mention can be solved with a basic flood-fill. Returning a valid path is slightly more complicated in terms of algorithm and vastly more complicated in terms of generating the output (but it's also more pleasant to look at). \$\endgroup\$ – Alexandre Halm Jan 11 '16 at 16:04
  • \$\begingroup\$ @AlexandreHalm I misread. I thought yours was to output a truthy also. (However, yours can be solved with a flood fill also, with only a small amount extra effort to remove the blocked paths.) \$\endgroup\$ – quintopia Jan 11 '16 at 16:14
  • \$\begingroup\$ @AlexandreHalm Speaking of which: what of mazes with multiple solutions? Since you do not require a path to be the shortest, would an output that includes all possible paths be valid? \$\endgroup\$ – quintopia Jan 11 '16 at 16:15
  • \$\begingroup\$ I'm not sure enumerating multiple possible solutions would be interesting. I could require to produce the shortest path, which would make it more challenging (but even then you're not guaranteed to have a unique optimal solution). Then, unless you're willing to try some super-exponential search, you'd have to implement something like A* \$\endgroup\$ – Alexandre Halm Jan 11 '16 at 16:36
  • \$\begingroup\$ To find any valid path requires something like backtracking algorithm. That could take a long time on any decent size maze (doing it double ended would help somewhat.) I think asking for the shortest possible is too much, unless the mazes are kept extremely simple. So I think it's more interesting as it is. But you should include wording similar to your reply to Nathan Merrill in the challenge text. Note that your text "shortest solution wins" is ambiguous (could be misinterepreted as shortest path through maze) and would be best changed to "shortest code wins." \$\endgroup\$ – Level River St Jan 15 '16 at 2:03
0
\$\begingroup\$

Iterating through Doubles

This challenge is relatively simple: You are passed two floating point numbers, a and b; you must print every floating point in between in order.

  • I don't care if your output includes a or b. You can choose to include/exclude them if you wish. For my examples, I will include a, but exclude b.
  • You can assume that a <= b
  • You should use IEEE 754 floating point numbers. As to the format of the numbers, I do not care, though I will be using binary32 in my examples.
  • Your program must not print any NaNs, infinities, or print out the same number twice. -0 is the same as 0.
  • Ifa or b cannot be perfectly represented in floating point, you must round-to-nearest them (standard for most languages). You can assume that a and b won't round to infinity.
  • Your program must have a runtime of O(N), where N is the total number of floating point numbers in between a and b.
  • Your program must not use more than O(1) storage. The only exception to this is for storing your output before printing it all.
  • Builtins that are able to generate floats in order are not allowed (such as Julia's nextfloat())

For the following examples, I have used this webpage to generate the numbers, and thus my examples may have human errors.

-5.6E-45, 5.6E-45
-5.6E-45, -4.2E-45, -2.8E-45, -1.4E-45, 0, 1.4E-45, 2.8E-45, 4.2E-45

-0, 0
No output, though printing either 0 or -0 would be allowed (but not both)

299.9998, 300.0002
299.9998, 299.99982, 299.99985, 299.99988, 299.9999, 299.99994, 299.99997, 300, 300.00003, 300.00006, 300.0001, 300.00012, 300.00015, 300.00018, 300.0002

1.9999998, 2.000001
1.9999998, 1.9999999, 2, 2.0000002, 2.0000005, 2.0000007, 2.000001

-3.4028235E38, -3.402822E38
-3.4028235E38, -3.4028233E38, -3.402823E38, -3.402829E38, -3.4028227E38, -3.4028225E38, -3.4028222E38

3.4028229E38, 3.4028235E38
3.4028229E38, 3.402823E38, 3.4028233E38, 3.4028235E38
\$\endgroup\$
  • 1
    \$\begingroup\$ 1. The header says doubles, but the question talks about binary32. Which of the various sizes permitted by IEEE 754 may be used? 2. More seriously, this is just a loop round an abuse of pointers (in C) or a library function to convert a bit-pattern from int to float (in pretty much any other language which supports IEEE 754). It doesn't offer much scope for creativity. \$\endgroup\$ – Peter Taylor Jan 10 '16 at 19:29
  • \$\begingroup\$ @PeterTaylor I was hoping to find some cases of duplicated numbers, but I haven't found any. I realized that this was because the radix I'm using is 2. Would it be interesting if I enforced a radix of 10? Not every language has floating points like that (Decimal in C# is the only one I know of), so I'm not sure how relevant this challenge would be. \$\endgroup\$ – Nathan Merrill Jan 10 '16 at 21:26
  • \$\begingroup\$ Sorry, I'm lost. Duplicated numbers? \$\endgroup\$ – Peter Taylor Jan 10 '16 at 21:41
0
\$\begingroup\$

Coaxial and Copolar?

Introduction

SANDBOX NOTE: Diagrams soon

Copolar: Two triangles ABC and A'B'C' (not necessarily in the same plane) are said to be copolar if and only if the lines AA', BB', and CC' are concurrent at one point V.

Coaxial: Supoose two triangles ABC and A'B'C' are defined such that AB and A'B' intersect at X, AC and A'C' intersect at Y, and BC and B'C' intersect at Z. Then, the two triangles ABC and A'B'C' are said to be Coaxial if and only if X, Y, and Z are collinear.

Desargue's Theorem: Copolar triangles are coaxial, and conversely.

The Challenge

Your challenge is to write two entire programs (but not necessarily in the same language, if you so desire) which detect whether or not two triangles are Coaxial/Copolar. One program must detect the existence of V, and the other must check the collinearity of X, Y, and Z (As defined above). You should provide some explanation or proof that your two programs perform these two different checks. Your score in this challenge is the Levenshtein distance between the two programs, with lowest score being dubbed winner.

Input

You will receive 6 vectors, all of which containing an x, y, and z floating-point Cartesian coordinate, to represent the vertices of ABC and A'B'C'. This information may be received by your program in any convenient format, including command line arguments, nested lists, etc. The two programs you submit should take input in the same manner.

Output

Your program should print a truthy value if ABC and A'B'C' are coaxial/copolar, and a falsey value otherwise. As this will likely require floating-point calculations, we establish some leniency:

Choose a constant value 0 < ERR < 0.01, for use in both programs.

  • If the pairwise intersections of AA', BB', and CC' intersect within ERR units of one another, the given triangles should be considered copolar.

  • If the point Z lies closer than ERR distance from the line XY, the given triangles should be considered coaxial.

Standard techniques for checking floating point calculation equality should be sufficiently accurate for this challenge.

Since copolar triangles are also coaxial, the programs should output the same value in all but extreme cases.

It should be assumed that any cross section of the cartesian space provided is an Extended Euclidean Plane. Note that it is possible that the vertex V or any of X, Y, and Z may be an ideal point, and this is a case that should be prepared for.

Test cases

SANDBOX NOTE: Coming soon...

\$\endgroup\$
  • \$\begingroup\$ Levenshtein distance between two programs has been tried before and is now well-known to be completely useless as a winning criterion. Anyone with half a brain can score 1, and sometimes it's even possible to vary the input enough to detect the cases and score 0. \$\endgroup\$ – Peter Taylor Jan 11 '16 at 11:09
0
\$\begingroup\$

Cookies are being served! Sibling rivalry ensues! Each of the twins wants the maximum quantity of cookie. The problem is that the cookies are of somewhat different sizes, not surprising since they are home baked. So you weigh each of the cookies and devise a program to help you allocate them to each twin such that the difference in total weight of the cookies each twin gets is minimized. Coding up the program is your task today!

Input

Each case is described on a single line that begins with the number of cookies (no more than 100) followed by the weight of each (in integer grams, no more than 1000 grams).

Output

For each case, display the minimum total weight difference.

Sample Input

5 6 8 5 2 6

2 25 62

Sample Output

1

37


I asked this earlier and it was put on hold. Not sure what needs to be changed.

\$\endgroup\$
  • 1
    \$\begingroup\$ First you need a winning criterion. Code golf (shortest valid code wins) would work well here. Another possibility would be fastest code, but that would be harder to judge - you'd probably need to run every answer on your machine, in a number of different languages. Popularity contest is hard to write a good question for, and is best saved for questions where there is no other way of judging. If you don't have a strong preference, I'd go with code golf. \$\endgroup\$ – trichoplax Jan 11 '16 at 3:37
  • 1
    \$\begingroup\$ An edge case to consider: Will the input ever be just 0 followed by no cookies? Whichever way you decide, it's worth mentioning this explicitly in the question so people know whether to plan for that. \$\endgroup\$ – trichoplax Jan 11 '16 at 3:42
  • 1
    \$\begingroup\$ You had asked for the total weight of cookies to be minimized, which I suspect was not what you intended, so I've edited it to ask instead for the difference in total weight to be minimized. If this wasn't what you intended feel free to roll back the edit. \$\endgroup\$ – trichoplax Jan 11 '16 at 3:47
  • 1
    \$\begingroup\$ That clears it up a lot, thank-you, @trichoplax \$\endgroup\$ – Tanner Jan 11 '16 at 3:54
  • \$\begingroup\$ You're welcome. You'll still need to do some further editing to address my first 2 comments, then after that hopefully others will comment with anything else that needs improving that I've missed. \$\endgroup\$ – trichoplax Jan 11 '16 at 4:50
  • \$\begingroup\$ This is a trivial variant of this older question and IMO close enough to count as a dupe. \$\endgroup\$ – Peter Taylor Jan 11 '16 at 11:07
  • \$\begingroup\$ I believe the question was closed as a duplicate of this because it's exactly the same, just about cookies instead of shopping bags. \$\endgroup\$ – user81655 Jan 15 '16 at 10:54
0
\$\begingroup\$

Count the ones!(better title needed)

[Sandbox-note: Is this really still code-golf?]

[Sandbox note: Need to find descriptive tags]

Void Corp needs you!

Thanks to extreme advancements in a technology called null-space we are able to compress any number of 0-bits into just one memory block. The problem is that storing 1-bits is extremely expensive now. To evaluate which data we should keep we need a program that count all 1-bits in a string. Sadly our programmer is currently in forced vacation after a caffeine-incident, so it is up to you now to help us out.

Your code should contain as few 1-bits as possible when stored in null-space.

We have heard of this strange Unary. As our programmer is the only one able to understand it, we are currently not able to implement it.

Task

Write a program that counts all 1-bits in a given string.

You may provide a function or fully functional program. Input will be provided via STDIN or argument and should be printed to STDOUT or returned.

Your answer must be in an existing language, especially the interpreter must already exist. No retro-active coding of a language that consists entirely of NUL (unless I missed it). [Sandbox note: Don't tell me there is such a thing.]

Scoring

Count the 1-bits in your code. Fewest amount wins.

[Sandbox note: Should add script to paste code into for evaluation]

Sandbox Questions

What do you think of the task? It seems pretty basic to me, the twist is the Scoring.

What do you think of the scoring? I want to encourage usage of obscure/lengthy commands which are normally not used in CodeGolf. Your opinion?

Does someone happen to have a script for evaluation lying around? Do you have anything to add?

Is appropriate for this question?

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

Fixed Width

Related.

We like fixed width. We want you to evaluate a string
on it's "fixed width"-ness. However, this string will
not be a regular string. This input will be presented
to your code as thus: "name1, name2, lin1,..., linN".

Each of linK is a single line of a transcript; you'll
assume that the speakers alternate, and that each lin
is will not have trailing whitespace, like this:     

You may take input in the form of a function or a program, as a string with commas, a list, or a series of arguments.

Say your input is rob, emily, hi, hey you, last night was nice, the best i've had. Then, the result would be:

<rob> hi
<emily> hey you
<rob> last night was nice
<emily> the best i've had

Then, this input would have a "fixed width"-ness of 2. This is what you would return/print. That is, you are to output the length of the longest run of fixed width messages.

Test cases

input => output

rob, emily, hi, hey you, last night was nice, the best i've had => 2
a, b, hello, hola!, no, what?, why, why not, abcdef, fededa, 012345 => 3

I think this should be , but I think this could also work as a fixed-width , maybe.

\$\endgroup\$

You must log in to answer this question.

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