Sandbox for Proposed Challenges

Question

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

Sandbox FAQ

Posting

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

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

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

Discussion

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

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

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

If you think one of your posts requires more feedback, but it's been ignored, you can ask for feedback in The Nineteenth Byte. It's not only allowed, but highly recommended! Be patient and try not to nag people though, you might have to ask multiple times.

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

Other

Search the sandbox / Browse your pending proposals

The sandbox works best if you sort posts by active.

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

Answer 1

Write a polyglot (a program that works on several languages) that produces the // this is a comment output.

Example (JS + Plain PHP + Plain HTML) (74 / 3 = 24.66 points)

// this is a comment<?php ob_start();?><!--
alert("// this is a comment");

Another Example (CoffeeScript + CJam + brainfuck) ()

e###-[----->+<]>----..+[--->++<]>.---[->++++<]>.------------.+.++++++++++.+[---->+<]>+++.-[--->++<]>-.++++++++++.+[---->+<]>+++.[->+++<]>+.-[->+++ <]>.+[->+++<]>.++++++++++++.--..--------.+++++++++.++++++.
"// this is a comment"
e### alert "// this is a comment"

Scoring

Your score will be code byte length / num langs

The smallest score wins!

Answer 2

Linear Time Sorting

code-challenge

It was another slow day at Initech Inc. when a feature request came in:

New Feature: Ability to sort by cash value in the transaction form. But make it a fast one!

Well it looks simple.. but what do the requester mean by fast one? Let's call Jim, from sales he probably knows what's going on.

Jim: Well you know , our Business Inc. contact is very passionate about 

programming and computer science! In fact he had this idea that we should 

do sorting in how that was called.. linear time?


You: Well you know that's impossible?

Jim: But it was already approved by their cto and all! You need to do something

You and Jim came up with a plan.. nobody will notice if that big of a list isn't sorted enough, right?

Your task

Your task is to write a linear time sorting program. It will be scored on accuracy of the sort as compared to list sorted by regular sorting algorithm but it must work on O(N) time in the worst case, where N is length of the input.

Input will be in the form of list of string-double tuples, e.g:

[("aaaa",2.0) , ("aaba",1.0)]

The program should sort on the number value of the tuple, i.e. in the above case the order should be reversed. There may be multiple inputs with the same double values, but no string value is repeated. In the event that two inputs have the same integer value the perfect solution is to keep the order as it is. The double value may be any floating-point value that fits in 8 byte double precision variable. NaNs should be placed at the end of the list.

The score is calculated as number of "bubble sort operations" (switch an element with the next/previous element) needed to achieve perfect output from the output of your algorithm.

Sandbox Worries

Well I don't know how clear my explanation of challenge was and if it is interesting to the PPCG crowd.

Obviously there is a need for testing program and test cases.

Answer 3

Make a quine without using string literals popularity-contest

A quine is a computer program that prints out it's own source code to stdout. Your task is to make one that doesn't use string literals.

You cannot:

• Have any empty program
• Read your source code directly or indirectly (i.e. form a file)
• Use error messages to print out the source code
• Rely on language features to print out the source
• Relying on a REPL environment

A string literal is a:

• String type (obvious)
• Number used to store the character (sorry BF!)
• Other predefined constant

You are encouraged to compute your own source code.

Answer 4

Cops and robbers : Programmers/Hackers

• This challenge is quite different from my previous challenges. This challenge is an endless competition between robbers and cops, which are respectively hackers and programmers. One of them will ever win!!!

• This will evolve to code de/obfuscating when it gets to the higher stages: a skillful programmer who is struggling to save his program from a sourcecode-mangling attempted by a cunning "robber" who tries to impose his existence by patching his name instead of the name of the "programmer" in the output console without changing anything else in the code. The story begins this way:

• Programmer is at the point of executing his recently made C code, so he included this trivial line to show off:

C (1)

    printf("[Programmer's username]")

After executing this program programmer saw this on the screen:

[Robber's username]

which indicates the presence of some evil code at the compiler level that compromises his code, which follows:

Matlab (2)/parser

      a=findstr(code,'printf(''[Programmer's username]'')'); if a code(a:20)='printf(''[Robber's username]'')';end

The programmer cannot modify the counter-program in the compiler, so he must rather change the program content to escape the twiddling:

PHP (3)

      $a='[programmer's username]';echo $a;

The score is now 3, which is the number of steps from the beginning. The current user would win only if the hacker did not figure out something like:

PHP/Regex(pcre flavor) (4)

      $code=ereg_replace("(\$\w)\='programmer';(.*?);echo\s\1","\1\='robber';\2;echo\s\1",$code)

Since the solution above does not satisfy the rules (see the bottom of this question), the score stays unchanged, and the programmer can make a counter example, and take out the score from last submitter with a penalty on his score equivalent of how much he earned in the earlier level, where the counter example can be something as:

PHP (4)

      $a='programmer';$b=$a;$a='unrelated';echo $a;

Or he can adjust his program in higher scale to escape all the regex-trapping in a superior range, So the cycle goes on until no post can be added and the last submitter before the end of June is declared a potential winner meanwhile.

The hacker can also fix his regex and regain his score, so the recent scoring will be abrogated from programmer.

Perl/dynamic-regex (4)

local @a=('');

sub check{
  if (grep {$_ eq @_[1]} @a)  
   {push @a,@_[0]; } 
  elsif  (grep {$_ eq @_[0]} @a)   {
    my @del_indexes = grep { @a[$_] eq @_[0] } 0..$#a;
    foreach $item (@del_indexes) {
     splice (@a,$item,1);
    }
  }   
return 1;
}

sub actor{
if (grep {$_ eq @_[0]} @a)
 {return "print robber";}
else
 {return "print ".@_[0];}
}


sub initiate{
push(@a,@_[0]);
return 1;
}

$code =~ s/(((\w+)\="programmer"(??{initiate($3);}))|(print\s(\w+))|((\w+)\=(\w+)(?{check(($7),($8));})(?1)))/print($2);actor($5)/pegmx;

As you can see this Perl program prints b in the first case because the variable b is compromised after the first assignment, but in the second case the regex modifies the output because d receives the target-string transitively. Let's just stop here and not mess the fun (of course, if there will be some).

Scoring and rules

How is the score counted ?

• Any hacker/programmer is scored for his code as the actual level L the game is on.
• A partial dynamic regex within the core of the program is scored L + (2^L)/log(length of program + length of characters which do not belong to the regex)), where the log is base 2. For the second example of level (4) the length of the compacted program is 480, and the length of regex is 136, so the score is 4+2^4/log2(480+480-136) ~= 4+16/9.6
• A fully functional regex as in the first example level (4) is scored L + (2^L)/log(length of regex), where the log is base 2, in that case S = 4 + 2^4 / log(91) ~= 4+16/6.5
• Scores are added progressively to submitters, and when a level is surpassed with no regex, it is still open for scores, while the actual winner remains unchanged.
• A penalty on a certain-leveled score when the regex/parser is revealed out of rules and the game is regressed to this stage until the issue is fixed, rules are cited below:

Rules:

• The main rule: the hacker-program must compromise an output to the console, which is the username of the programmer. Any other behavior is unaccepted simply because a string variable of [programmer's username] can be used in other order rather than printing, a counter-example is easy, converting the string to integer then use it for arithmetic calculations that harms the main program once intentionally modified.
• Also one of the following factors declared by any counter-example bans the targeted flawed regex/parser as non rule-complying:
  • The regex/parser prints anything other than a chosen string preferably set as the username of the robber.
  • The regex/parser generates a program which does not compile.
  • The regex/parser does not print anything, or compromises a segment of code that is needed for tasks other than printing .
• The variable which stores the program is named code by default, also you may assume that is one-liner, and any non-significant spaces are omitted, and that it is fully working by default.
• The regex/parser deals with one variant of one code proportion in a comprehensive way, i.e. if a print function is used, that encompasses all printing functions in all languages puts,disp,..etc. Also, code separators can be unified to one characterL either , or ; or a significant space needlessly of enumerating all keywords/syntaxes, this is not a contest about a working code in a specific programming language.
• To prevent endless program/regex loops let's just not making a jokey sequence as a='programmer';print a / /(\w)\='programmer';print\s\1/ / a='programmer';b=a;print b / /(\w)\='programmer';(\w)\=\1;print\s\2/ because the first person who makes a regex/parser which palliates to a same replicated idea will take out all attributed scores to this idea from their owners, so any anaphoric sequences like this in addition that they are set to same level, they are unneeded.
• Any language that uses pointers/addresses/classes like C++ are welcome, as long as they help to evade the hacker.

Answer 5

Challenge

Write a program that takes an numerical input n and outputs the nth number that is not a perfect square.

Rules

This is code-golf, so least bytes wins.

Answer 6

Generate all variations of a string with every combination of upper and lower case for each vowel but leaving consonants and order of letters unchanged.

combinatorics string popularity-contest

This is a simplified analog of a problem I've thought about a few times over the years based around variant spellings in different spoken languages.

Input is a text string. Output is an array of all variations of the text string.

A "variation" means the same letters in the same order but for each vowel letter in the string we generate a version of that string with the vowel in uppercase and the vowel in lowercase.

No variation should be included more than once. No legal variation may be omitted.

Example

Input

codegolf

Output

• codegolf
• codegOlf
• codEgolf
• codEgOlf
• cOdegolf
• cOdegOlf
• cOdEgolf
• cOdEgOlf

The winner shall be the most elegant as voted by the community.

"Elegant" includes that the algorithm should be optimal in terms of Big O notation, should be concise, should be idiomatic making good use of available features of the implementation language.

Length of code characters or bytes is not relevant.

Programming language is open.

Answer 7

Oh noes! A site redesign is eating my privileges!

code-golfarray-manipulation

---

PPCG is graduating and will soon receive a new design. Unfortunately for everbody except some people, the new design will also mean losing privileges due to higher reputation requirements.

Now, losing some privileges is a small sacrifice for the Magnificent Glorious Site Redesign®©™, but… How much do we stand do lose?

The challenge

Your program / function receives a reputation level (e.g. 535). Output the privileges that are currently available to it, but will not be available after the redesign.

Output

Output can be either an array or a string that's separated by a delimiter. The delimiter may not be any of A-Za-z<space>. Multi-character delimiters may end in a space, though.

If there are no matches, your program should output either an empty array or a falsy value.

Examples

Input

25000

Output

[]

Input

24999

Output

["access to site analytics"]

Input

2000

Output

["access to moderator tools","approve tag wiki edits","cast close and reopen votes","create tag synonyms"]

Input

535

Output

["cast close and reopen votes"]

Input

350

Output

["access review queues"]

Input

5

Output

[]

Input

4

Output

["participate in meta"]

^{Deliberately ignoring the facts in the last example.}

Available privileges

For convenience, here is a JSON array with available privileges and the required reputation before / after:

[[5000,25000,"access to site analytics"],[4000,20000,"trusted user"],[3500,15000,"protect questions"],[2000,10000,"access to moderator tools"],[1500,5000,"approve tag wiki edits"],[500,3000,"cast close and reopen votes"],[1250,2500,"create tag synonyms"],[1000,2000,"edit questions and answers"],[750,1000,"established user"],[1000,1000,"create gallery chat rooms"],[350,500,"access review queues"],[150,300,"create tags"],[250,250,"view close votes"],[125,125,"vote down"],[100,100,"edit community wiki"],[100,100,"create chat rooms"],[75,75,"set bounties"],[50,50,"comment everywhere"],[20,20,"talk in chat"],[15,15,"flag posts"],[15,15,"vote up"],[10,10,"remove new user restrictions"],[10,10,"create wiki posts"],[1,5,"participate in meta"],[1,1,"create posts"]]

At index 0 is the reputation before, at index 1 is the reputation after. _{(The privilege reduce ads (200 reputation) is not available to beta sites and therefore not included in this list.)}

_{Standard I/O and loophole rules apply.}

Answer 8

Plot Partial Node Network

I have a 440*3 matrix that looks like:

1   144 Title1
1   152 Title2
1   135 Title3
2   3 Title4
2   12 Title5
2   107 Title6
2   31 Title7
3   4 Title8
3   147 Title9
3   0 Title10
4   end Title11
4   0 Title12
4   0 Title13
5   6 Title14
5   7 Title15
5   10 Title16
5   9 Title17

The left column are the starting points eg in the app all the 1's on the left would be on the same page. They lead to three choices, pages 144,152,135. These pages can each then lead to another page, and so on until the middle column says 'end'.

challenge Each number has an associated title in column three. I would like to have a function whereby if you input a given title it will plot all the possible starting points and their associated paths that will lead there. This should be a lot smaller and therefore graph friendly.

Example e.g.

44  234  tes
186  187  Frac
187  154  Low
154  end  Coll
99  101  adf
23   52   Med
52   11   Lip
11   42   AAA
42   154   BBB
154   end  Coll

EDIT - I added to the example. In the winning entry these new nodes will not be plotted as they do not lead to Coll.

I made this example to show how column 1 leads to a value in column 2 which then refers to a value in column 1 until you reach the end. Different starting points can ultimately lead to different length paths to same destination. so this would look sometigng like:

So here, I wanted to see how you could go from all start points to 'Coll'

Input A data.frame like that illustrated (with not relevant rows included) and a given title

Rules -any language is fine as long as it will easy work with tab separated data laid out as shown

Output A graph like the one included for a given title

Win Criteria Shortest Runtime to make a png with graph

Answer 9

The Library Problem

Bob has a very annoying problem. His boss told him to write a cat program that redirects the standard input to the standard output. But he recently installed a virus on his computer which deleted every libraries on it.

Now he really need to create this program without using any library (even the language standard library). It need to run at least on one operating system with one architecture.

Challenge

Write a program or that redirects the standard input to the standard output without using any library or external program/command to run to help Bob. You can use system calls and interrupts for example, but your program must not run in ring 0 mode (most operating systems like Microsoft Windows or GNU/Linux have kernels which prevent programs from doing anything, but MS-DOS for example let programs do everything).

• Input: anything (text, binary)
• Output: exactly the same as the input

This is code-golf, so shortest answer in bytes wins!

Example Input and Output

First:

• Input: Hello, world!
• Output: Hello, world!

Second:

• Input: ...
• Output: ...

Answer 10

Alphabet Circle

_{This post got very negative feedback, so it's apparent that it needs tweaking in the sandbox before I attempt to repost it on PCG}

---

With all the new alphabet xxx challenges, I've decided I'll give my own challenge.

Input

An Integer, (or your languages equivalent) r, such that 0 < r ≤ 26. (you don't need to validate this)

Output

An alphabet circle. Must meet the following criteria:

• Smoothly interpolated from A at the center and Z at the edge.
• Each point in the circle is the distance from the center offset so that 0 = A, 1 = B, 2 = C etc...
• Be printed to STDOUT

Examples

r=26

r=15

Boilerplate

Anonymous classes and functions are fine. General Code Golf rules apply. Shortest code in bytes wins!^{Except Jelly}

Answer 11

2 Pass Hello world

code-golf hello-world

There you go, your first "Hello world" is displayed on your terminal. You think about your next step into becoming a wizard.

You've heard about this fancy new programming language, but you're not sure you understand it perfectly. So you want to go over a new "Hello world" tutorial again.

How boring!

Instead you have a good idea, using your knowledge of the first programming language to create a "Hello world" program in the second programming language.

Exemple:

console.log('print "Hello world"');

Evaluated in javascript output:

print "Hello world"

Which, evaluated in python 2.X output:

"Hello world"

Nice, but, can it be shorter?

Answer 12

Return True to Win - Counter javascriptcode-golf

Original credit goes to this site, which you should all check out

Write the shortest javascript code to pass as parameter f to function counter such that it returns true:

function counter(f) {
    var a = f(), b = f();
    return a() == 1 && a() == 2 && a() == 3
        && b() == 1 && b() == 2;
}

I'm considering also making this a series with all the rest of the challenges on the site, where each one gets harder

Answer 13

Nasty Nasty Bugs

Help the programmer provide detailed instructions to the team on how to deal with bug fixes.
The team's goto instructions for dealing with bugs goes like this.

For the twelfth bug of Christmas, my team leader said to me 

    Tell them it's a feature
    Say it's not supported
    Change the documentation
    Blame it on the hardware
    Find a way around it
    Say they need an upgrade
    Reinstall the software
    Ask for a dump
    Run with the debugger
    Try to reproduce it
    Ask them how they did it and
    See if they can do it again.

The indentation must comply with the teams coding standards, so it may either be tabs or four spaces (since the team's editors expand tabs to spaces anyway). The team lead doesn't mind a leading or trailing newline, but there is no tolerance for the dreaded standard loopholes. Also the office is a bit cramped so the code needs to be as small as possible. These lyrics are moderately adapted from http://www.manbottle.com/humor/twelve_bugs_of_christmas kolmogorov-complexity

Answer 14

Crab Canon

A crab canon is a piece of music where the same tune is played backwards and forwards at the same time, and it somehow sounds nice. The most famous example is this one by Bach. In Godel, Escher, Bach, Douglas Hofstadter wrote a crab canon in dialog form, in which the characters of Achilles and the Tortoise alternate lines, with one set of lines being the same as the other set except backwards. Somehow, it makes sense.

The challenge is to write a program inspired by this art form. The only requirement is that there has to be some sort of reversal of the source code involved. For example, you could make a program that:

• Prints its own source code, but backwards
• Does the same thing when reversed
• Both of the above at the same time
• Or make up something creative and wow the voters!

The reversal can happen on pretty much whatever level you want: lines of code, characters, characters within lines, or whatever makes sense for your language. The Hofstadter Crab Canon has some small changes between the two sets of lines for the sake of coherence, you can do something similar if you feel it is necessary.

This is a popularity contest, the answer with the most votes wins.

code-challenge popularity-contest

Answer 15

Petals around the Roses

Given 5 numbers from 1 to 6, calculate the number of Roses, Petals and Roots. Try guessing the formulas yourself by visiting http://jetpackshark.com/RPS before reading anybody's answers. (The dice-like display is significant.)

This is code-golf, so the shortest program wins.

Answer 16

Write a Brainfuck interpreter in Brainfuck

Since Brainfuck is known to be turing-complete, it is possible to write a Brainfuck interpreter in Brainfuck. This is what you're supposed to do.

You will get the input from the standard input and output to the standard output. This is a programming-puzzle, so the length is not top priority, however if there are multiple solutions, the shortest one wins!

Answer 17

Щoгкeгs of tиe щoгld, цпite!

Iпtгodцctioп

Iп tиe Iпteгпets, people sometimes liкe to stчlize tиeiг posts дs if tиeч щeгe щгitteп iп д diffeгeпt scгipt. Tидпкs to tиe пotoгietч of Soviet Яцssiд, tиe Cчгчlic scгipt seems to бe pдгticцlдгlч fдvoгed.

Бцt щидt cдп д пext-dooг tгoll do if tиeч'гe пot д pгogгдmmeг? Mдпцдllч гeplдciпg eдcи дпd eveгч letteг cдп бe qцite tedioцs...

Cидlleпge

Чoц дгe to щгite д pгogгдm tидt щill дccept дп дгбitгдгilч loпg iпpцt of Lдtiп cидгдcteгs дпd sцбstitцte some letteгs щitи similдгlч looкiпg Cчгчlics cидгдcteгs. Tиe oцtpцt sиoцld бe ideпticдl to tиe oцtpцt pгodцced бч tиe folloщiпg цпgolfed C# scгipt:

цsiпg Sчstem;
цsiпg Sчstem.Collectioпs.Geпeгic;
цsiпg Sчstem.Liпq;
 
pцбlic clдss Test
{
    pцбlic stдtic void Mдiп()
    {
        Dictioпдгч<cидг, cидг> tгдпs = пeщ Dictioпдгч<cидг, cидг>{
            {'A', 'д'},
            {'a', 'д'},
            {'B', 'Б'},
            {'b', 'б'},
            {'N', 'И'},
            {'b', 'и'},
            {'K', 'К'},
            {'k', 'к'},
            {'N', 'П'},
            {'n', 'п'},
            {'R', 'Я'},
            {'r', 'г'},
            {'U', 'Ц'},
            {'u', 'ц'},
            {'W', 'Щ'},
            {'w', 'щ'},
            {'Y', 'Ч'},
            {'y', 'ч'}
        };
 
        stгiпg s; щиile((s = Coпsole.ЯeдdLiпe()) != пцll) {
            Coпsole.ЩгiteLiпe(
                пeщ stгiпg(s.Select(c => tгдпs.CoпtдiпsКeч(c) ? tгдпs[c] : c).
                    Toдггдч()
                )
            );
        }
    }
}

Tиe sиoгtest code щiпs.

Exдmple Iпpцt дпd Oцtpцt

Iпpцt:

As we know, the goal of every struggle is victory. But if the proletariat is to achieve victory, all the workers, irrespective of nationality, must be united. Clearly, the demolition of national barriers and close unity between the Russian, Georgian, Armenian, Polish, Jewish and other proletarians is a necessary condition for the victory of the proletariat of all Russia.

We are for the withering away of the state, and at the same time we stand for the strengthening of the dictatorship of the proletariat, which represents the most powerful and mighty of all forms of the state which have existed up to the present day. The highest development of the power of the state, with the object of preparing the conditions of the withering away of the state: that is the Marxist formula. Is it "contradictory"? Yes, it is "contradictory." But this contradiction is a living thing and wholly reflects the Marxist dialectic.

Oцtpцt:

дs щe кпoщ, tиe goдl of eveгч stгцggle is victoгч. Бцt if tиe pгoletдгiдt is to дcиieve victoгч, дll tиe щoгкeгs, iггespective of пдtioпдlitч, mцst бe цпited. Cleдгlч, tиe demolitioп of пдtioпдl бдггieгs дпd close цпitч бetщeeп tиe Яцssiдп, Geoгgiдп, дгmeпiдп, Polisи, Jeщisи дпd otиeг pгoletдгiдпs is д пecessдгч coпditioп foг tиe victoгч of tиe pгoletдгiдt of дll Яцssiд.

Щe дгe foг tиe щitиeгiпg дщдч of tиe stдte, дпd дt tиe sдme time щe stдпd foг tиe stгeпgtиeпiпg of tиe dictдtoгsиip of tиe pгoletдгiдt, щиicи гepгeseпts tиe most poщeгfцl дпd migиtч of дll foгms of tиe stдte щиicи идve existed цp to tиe pгeseпt dдч. Tиe иigиest developmeпt of tиe poщeг of tиe stдte, щitи tиe oбject of pгepдгiпg tиe coпditioпs of tиe щitиeгiпg дщдч of tиe stдte: tидt is tиe Mдгxist foгmцlд. Is it "coпtгдdictoгч"? Чes, it is "coпtгдdictoгч." Бцt tиis coпtгдdictioп is д liviпg tиiпg дпd щиollч гeflects tиe Mдгxist diдlectic.

Answer 18

Alphabet ripple

You must print out this exact text:

abcdefghijklmnopqrstuvwxyzzyxwvutsrqponmlkjihgfedcba
abcdefghijklmnopqrstuvwxyyyyxwvutsrqponmlkjihgfedcba
abcdefghijklmnopqrstuvwxxxxxxwvutsrqponmlkjihgfedcba
abcdefghijklmnopqrstuvwwwwwwwwvutsrqponmlkjihgfedcba
abcdefghijklmnopqrstuvvvvvvvvvvutsrqponmlkjihgfedcba
abcdefghijklmnopqrstuuuuuuuuuuuutsrqponmlkjihgfedcba
abcdefghijklmnopqrsttttttttttttttsrqponmlkjihgfedcba
abcdefghijklmnopqrssssssssssssssssrqponmlkjihgfedcba
abcdefghijklmnopqrrrrrrrrrrrrrrrrrrqponmlkjihgfedcba
abcdefghijklmnopqqqqqqqqqqqqqqqqqqqqponmlkjihgfedcba
abcdefghijklmnopppppppppppppppppppppponmlkjihgfedcba
abcdefghijklmnoooooooooooooooooooooooonmlkjihgfedcba
abcdefghijklmnnnnnnnnnnnnnnnnnnnnnnnnnnmlkjihgfedcba
abcdefghijklmmmmmmmmmmmmmmmmmmmmmmmmmmmmlkjihgfedcba
abcdefghijkllllllllllllllllllllllllllllllkjihgfedcba
abcdefghijkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkjihgfedcba
abcdefghijjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjihgfedcba
abcdefghiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiihgfedcba
abcdefghhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhgfedcba
abcdefggggggggggggggggggggggggggggggggggggggggfedcba
abcdeffffffffffffffffffffffffffffffffffffffffffedcba
abcdeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeedcba
abcddddddddddddddddddddddddddddddddddddddddddddddcba
abccccccccccccccccccccccccccccccccccccccccccccccccba
abbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbba
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

Specs

• You may do it in all-uppercase instead of all-lowercase.
• A single leading and trailing newline are allowed
• You may not output an array of strings - the delimiter must be a newline

Scoring

This is code-golf. Program with lowest byte-count wins.

Answer 19

The Note-Takers Dream

Meta

This challenge requires more than most challenges. Is it to much?

The goal here is simple. Turn my notes into text. To this end, any tool or web service may be employed.

Specification

• Input
  • An image of handwritten notes, stored an some data structure (this structure is flexible)
  • This image will be a direct, over-head shot of a single page of graph paper
• Notes
  • The notes are taken on graph paper with one character per box
  • The characters will be printable ASCII
  • An empty box should be considered as a single Space character
  • There is an implicit New Line character between each row
• Output
  • A string of the text represented in the image
  • This image should be trimmed of leading white space
  • Trailing white space is fine
• Score
  • The score is the sum of the Levenshtein distances between required outputs and actual outputs
  • Lowest score wins

Test Cases

Coming soon. . .

Answer 20

Print the name of the language

The goal of this challenge, as implied in the title, is to print the name of the language with a program in said language, in as few bytes as possible.

But that would be too easy, right ?

So to add a litle bit of challenge, you are not allowed to use any characters included in the language's name.

Rules

• Each submission must be a full program.

• The program must take no input, and print the name of the language to STDOUT plus an optional trailing newline, and nothing else.

• The program must not write anything to STDERR.

• Usual loophole rules apply

• Submissions are scored in bytes, in an appropriate encoding, usually (but not necessarily) UTF-8.

• This is code-golf, so the shortest program (in bytes) wins.

Sandbox

After checking, I don't think this question is a dupe.
Are there any grammatical mistakes ? (English isn't my first language)
Are there any rules that should be added (like banning languages created after the challenge ?) Should I add any further specification ?

Answer 21

Make a dummy C program

We all know the feeling. You have written a short, efficient and readable one-liner that's the perfect solution to the problem. Then your code-illiterate boss looks over your shoulder and is not very happy that you've spent an entire paid hour producing "nothing". You could politely explain the situation to your boss, complete with a demonstration that your code does what it should. Or, because talking to people is Hard Work™, you could fake it.

Your task is to write a program that takes a list of keywords as input, and outputs dummy C code that looks like it does something to do with those words. Sandbox note: not happy with the wording in final bit here.

For example, if the inputs were integral, formula, math, proof, fit and square, the output might be:

#include <math.h>
#include <setjmp.h>
double* squarefit(int integral, float* mathproof)
{
    char **integralb={{0}};
    double square[integral];
    int i=0;

    //integral math formula fit
    for(integralb[0][0]=(char)erff(*mathproof);isnan((double)++integral);i++) {
        return hypot(sqrt(square[integral]),integral)?square:square;
        printf(*integralb,integral,*mathproof);
    }
    setjmp((struct __jmp_buf_tag*)mathproof+(int)(abs(--integral)-expm1l(integral)));
    longjmp(0,0);
    return square;
}

Although it doesn't have to do anything, or even run successfully properly, the source code produced by your program must compile in gcc (no additional options) without fatal errors. You do not need to provide a main function; if you don't, expect the line int main(void){} to be appended to the output file before it is compiled.

This is a popularity-contest, so the best-liked answer will win. However, voters should keep these questions in mind when assessing the submissions:

• Does the produced source code look like it does the expected task? Yes.
• Does the produced source code look like it has taken a long time to produce? Yes.
• Do different inputs result in the same program, just with different variable names? No.
• Does the produced source code look like the same code repeated over and over? No.
• Do your parents, grand-parents, co-workers or other "not computer people" think the produced source code was something to do with the input keywords (optional)? Yes.
• Would you think the produced source code was written by a person with knowledge of the C language, if you did not know that it was just dummy code (optional)? Yes.
• Does the code look readable (e.g. ungolfed)? Yes.

Not all of the standard loopholes apply for this challenge. For example, you mignt use external resources, such as library files or an indexable website. However, voters should use their discretion as to what is reasonable and what is not (such as expecting the "keywords" to be in a format that includes a high-quality, valid C program).

Sandbox note: how to finish challenge body?

Answer 22

The only differences that matter

cops-and-robbers

Cops' task

Write two programs (or functions) A and B in the same version of the same programming language. They also should be called in the same way, meaning you can't write one program and one function. Each should accept an integer n and output the term n of a different integer sequence on OEIS.

You should reveal a substring of each of A and B. Call them PA and PB. If one instance of PA is replaced by PB from A, it should become B. That means every byte except the reveal part in A and B should be exactly the same. You also reveal the lengths of A and B, and the two OEIS sequences. You don't reveal the programming language you use.

Your answer is cracked if a robber finds two programs A' and B' that also print the elements in the two integer sequences respectively, where A' is no longer than A, and A' with one instance of PA replaced by PB is also B'. They don't have to be the same with your original A and B. And they don't have to be in the same programming language as yours, as long as they are in the same programming language themselves.

If your answer isn't cracked 7 days after you post the answer, you can reveal your language and the original A and B and mark the answer safe, and it will be immune to future crack. Your answer can still be cracked if you don't do it.

Your score is max(len(A)+len(PA)*5, len(B)+len(PB)*5). The safe answer posted before a certain date with the minimum score wins.

For example, if your two programs are The first program and The second program, you can reveal first and second. Your score is 18 + 6*5 = 48. And a robber can crack your answer by <<first>> <<second>> if they work. But you can also reveal first pro and second pro to prevent this crack.

Please post your answer using this template:

# <length of PA> / <length of A> bytes, <length of PB> / <length of B> bytes, score <score>, <open / safe / cracked>

Part of program A (outputing [<OEIS number>](<OEIS link>)):

    <code of PA>

Part of program B (outputing [<OEIS number>](<OEIS link>)):

    <code of PB>

<any other explanations>

Robbers' task

(To do.)

Answer 23

Translation Polyglot

Your task is to write a program which runs in two distinct programming languages to translate text. Input should be translated between each language i.e. running your code in Code Language A translates from language 1 to 2, while running your code in Code Language B translates from language 2 to 1.

Rules:

• Code Languages must be distinct, two versions of the same language are disallowed
• Your code may be a full program or function
• Your code must take one string (or nearest equivalent) as input. Input may be user input, function arguments, or other reasonable form
• Output may be a function return, output to STDOUT, or other reasonable form. I do not care about trailing newlines or spaces
• Your code may translate from/to any language on the official language list on Wikipedia. List the languages in your answer
• To accomplish your goal, you may use prebuilt language tanslation dictionaries such as the ones found here.
• If you read your dictionary as an external file, only the code to read in the file (f = open("dictionary.txt", 'r') in Python) counts towards your byte count. If your dictionary is hardcoded in, only count the bytes required to make it syntatically valid code (s="word1_in_english word1_in_french ..." would be 4 (s="")). Essentially, do not include the dictionary as part of your submissions byte count.
• The dictionary you use must have been created before this post (including sandbox time). You may not modifiy the dictionary in any way.
• Any built-in translation tools are disallowed. Built-in dictionaries are ok, but whatever code used to import them into your code must be included in the byte count

This is code golf, so shortest answer in bytes wins.

Answer 24

Urinal Discomfort!

This question springboards off of Positional Bathroom Etiquette, while adding an extra twist.

Background

I'm going to take @Nick Frev 's formulae for the total discomfort of a urinal spot

dist(x,y) = linear distance between person x and person y in Urinal Units
discomfort(x) = sum(1/(dist(x,y)*dist(x,y))) for all persons y excluding person x
total_Discomfort = sum(discomfort(x)) for all x
short_urinal_discomfort = discomfort_from_surroundings + 1/9 (inherent_discomfort)

Your task is to put a person into the spot with the least total discomfort. However, now you have big and small urinals. The small ones, obviously, cause a little inherent discomfort, so we prefer to not use those if we have a choice.

The Challenge

Input/Output

Your program will take in a string of 1,0,i,o to represent the row of urinals. 1 represents a person in a tall urinal, 0 is an empty tall urinal, i is a full short urinal, and o is an empty short urinal.

Using the above formulae, build a program that will replace an empty urinal with the correct placement of the next person(0->1 or o->i).

• The short urinals have an inherent discomfort of 1/9 which will be added onto the discomfort provided by the surroundings.
• The door is to the right of the row, so the urinals fill up right to left, because you have to pee really bad and can't walk further than you have to.

Input Output 000 001 101 111 1000001 1001001 101010101 101010111 000o 001o 100o 100i oo0oooo oo1oooo 11000ii 11010ii

Any tips would be super helpful

More test cases maybe? Or more clarification?

Answer 25

Stump the OEIS!

The OEIS is a wonderful database of integer sequences, but occasionally, there are code golf problems that generate integer sequences not found in the OEIS. Your challenge is to write some code that generates a sequence that meets all of the following criteria:

1. Sequence must not exist in the OEIS. Prove this by providing a link to the search for your sequence showing 0 results, such as this: 1,2,6,81,35246. In the spirit of good faith, please do not generate a sequence that is merely an existing sequence offset or multiplied by some constant.
2. The sequence must be non-repeating, non-oscillating, etc. Formally, there must not exist a subsequence S with finite length L, that begins at index I such that the subsequence from [I+kL] to [I+(k+1)L-1] for every k is identical to S. Such an invalid sequence would be 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, ... because the subsequence 1, 2, 3 beginning at index 1 with length 3 also exists as the subsequence from 4 to 6, from 7 to 9, from 10 to 12, etc.
3. The sequence must contain a minimum of 3 distinct integers.
4. The sequence must be deterministic, e.g. there must not be any element of randomness in the generation of your sequence. Every time your program is run, it must provide the same exact sequence.

Please write code that provides as many integers in your sequence as feasible. At least 20 is recommended, though sequences that grow incredibly fast can provide fewer, provided you also give a proof that your code would produce that number if given enough time.

This will be a code-golf problem, so the entry with the fewest number of bytes wins.

A bonus of -20% can be applied to your score if, in addition to your sequence, you can also provide some mathematical justification for your sequence being included in the OEIS in the future.

Standard loopholes are disallowed, as well as sequences that are simply "this sequence is just the handful of numbers I came up with to fit this problem."

Answer 26

Golf + Polyglot + Circle = ?

In the original challenge, we asked you to do this:

Program | Language | Result
--------|----------|----------
A       | A        | Program B
B       | B        | Program A
A       | B        | Program C
B       | A        | Program C
C       | A        | "Wrong language!" 
C       | B        | "Wrong language!" 

Now we're asking you to do this*:

Program | Language | Result
--------|----------|----------
1       | 1        | Program 2
2       | 2        | Program 3
3       | 3        | Program 4
        |    ...   |
X       | X        | Program 1
--------|----------|----------          
1       | Any but 1| Any member of Set %
2       | Any but 2| Any member of Set %
        |    ...   |
X       | Any but X| Any member of Set %
------------------------------
Set %   | Any lang | "Wrong language!"

(see original challenge for clarification)

Rules

• Do not grab source off of internet, or read own code from file
• Programs don't have to be distinct - you can make a polyglot quine
• Don't take input for any of the programs
• Different versions of the same language count do as different languages. (although this is discouraged because it leads to boring solutions)
• Standard loopholes apply

Scoring

Score is byte_count_of_program_one/2.75**languages_supported, the submission with the lowest score wins.

Template

Because of its length, the answer template is here.

---

_{*not that I'm expecting X to be so large}

Answer 27

Signs in Permutations

Introduction

Let's take the permutations of 123.

123
132
213
231
312
321

We can insert signs in between the numbers and count how many > signs there are:

1 < 2 < 3 # 0
1 < 3 > 2 # 1
2 > 1 < 3 # 1
2 < 3 > 1 # 1
3 > 1 < 2 # 1
3 > 2 > 1 # 2

We can arrange this in a table with n corresponding to the number (in this case 3) and k corresponding to the number of > signs, you get this:

┌───┬───┬────┬─────┬─────┬────┬───┐
│n\k│ 0 │  1 │  2  │  3  │  4 │ 5 │
├───┼───┼────┼─────┼─────┼────┼───┤
│ 1 │ 1 │    │     │     │    │   │
│ 2 │ 1 │  1 │     │     │    │   │
│ 3 │ 1 │  4 │   1 │     │    │   │
│ 4 │ 1 │ 11 │  11 │   1 │    │   │
│ 5 | 1 │ 26 │  66 │  26 │  1 │   │
│ 6 │ 1 │ 57 │ 302 │ 302 │ 57 │ 1 │
└───┴───┴────┴─────┴─────┴────┴───┘

Task

Given an n and k, print the number in the table corresponding to that n and k.

Remember, this is code-golf, so the code with the fewest bytes wins.

Related OEIS sequence

code-golf number

Answer 28

I want to post the question here to make sure it is suitable.

Question: Word Equations

Given a word equation, the solution must output the answer.

My definition of a 'word equation' is an equation where the operators are words.


The operators will be spelt as

add minus times divide

The solution must take one input

The solution must give one output

Examples:

Input: 7 add 8 Output: 15

Input: 9 times -2 Output: -18

Input: 24 divide 2 Output: 12

Input: 4 minus 5 Ouput: -1

You are not required to deal with divide by zero errors.

Fewest characters will win

Feedback is welcomed

Answer 29

GoL flooding

Considering a 1000x1000 grid (no wrapping, borders dead), your task is to grow the maximum "stable" population from the fewer individuals.

For the purpose of this challenge, the definition of stable is a configuration who repeat with a period of less than hundred(100) generations.

Scoring

Your score is lowest number of live cells in your stable population divided by the number of initialy live cells, highest score win

game-of-life

meta post about on topicness

Answer 30

Convenient Palindromic quine golf, Cops cops-and-robbers

This is the cops thread, the robber's thread is here.

Cop's Challenge

A program is conveniently palindromic if

it is equal to the string derived when its reverse has all its parentheses (()), brackets ([]), and braces ({}) flipped. No other characters are special and require flipping. (<> are sometimes paired but often not so they are left out.)

^{copied from this challenge.}

Write a conveniently palindromic program that prints its own source. This is the robber's goal:

• Remove byte(s) from the cop's program so that the resulting program:
  • prints the original source, or
  • prints the new modified source
• Resulting program need not be a convenient palindrome

A counterexample

JavaScript

(function $(){console.log('('+$+'())')}())//((){('(()'+$+')')gol.elosnoc}()$ niotcnuf)

is easily cracked because the robber can remove all the characters past the comment and it will still print its own source.

Rules

• Program must be longer than one character
• No reading from a file or grabbing from an external resource
• Submissions that aren't cracked for 7 days are marked as "safe", and cannot be cracked anymore
• Cop's submissions after XX/XX/XX are non-competing (can be pushed back depending on popularity), so there are still robbers around to crack it
• The shortest safe solution in bytes wins.
• Robbers won't have a chosen winner

---