text
stringlengths 180
608k
|
|---|
[Question]
[
I presume you've all heard of the [Rosetta Stone](//en.wikipedia.org/wiki/Rosetta_Stone), an ancient stone found to have essentially the same passage written on it in three different scripts. This challenge is based upon that: you have to write three versions of the same program in ***different*** languages.
The three programs must output the first `n` [iban numbers](//en.wikipedia.org/wiki/Ban_number), `n` being a number input by the user. There are only 30,275 iban numbers, so **if `n` is *greater* than 30275, the program should return an error.**
The challenge of the Rosetta Stone was that the scripts didn't appear to be [mutually intelligible](//en.wikipedia.org/wiki/Mutual_intelligibility)–knowing one didn't automatically make the others understandable. Your three programs should similarly be mutually unintelligible. That is, you may not golf down a Python 2 program and then submit it (or a minor modification) as a Python 3 version too, nor a C program as C++, etc. To prevent this, the [Levenshtein distance](//en.wikipedia.org/wiki/Levenshtein_distance) between any two versions should be at least 25% of the length of the shorter of the two versions being compared, and at least 16 as an absolute numerical value. You may check conformance using this online [Levenshtein distance calculator](http://planetcalc.com/1721/).
The winner is the person with the shortest combination of programs.
[Answer]
# 424 ~~425~~: Haskell, Python 2, Perl
As they should for a true Rosetta comparison, all three programs work the same way, taking input from the first command-line argument and building up the list with the same rules, and variable names, where possible.
## Haskell, 171
```
import System.Environment
main=do i<-getArgs;putStr.show$[n|n<-[0..777777],all(`notElem`"5689").show$n,all(\d->n`div`d`mod`100`notElem`13:[30..39])[1,1000]]!!(read.head$i)
```
## Python 2, 156
```
import sys
print[n for n in range(777778)if all([c not in"5689"for c in str(n)])and all([n/d%100not in[13]+range(30,40)for d in[1,1000]])][int(sys.argv[1])]
```
## Perl, 97 ~~98~~
```
$i=@ARGV[0];die if $i>30275;for(0..777777){push@n,$_ if!(/[5689]/ or/(13|3.)(|...)$/)}print@n[$i]
```
] |
[Question]
[
Create an algorithm that uses [Cramer's Rule](http://www.purplemath.com/modules/cramers.htm) (with determinants of matrices) to solve for the solutions of a system of linear equations. The code should work for an "n" number of variables.
**You may use whatever data structure you want to hold the matrix and return the result**
**Note:** Also, consider that a possible system can have no solutions and may have infinitely many solutions **:)**, so, your solution should take account of this...
If this is the case, just print out or return "none" or "infinitely many".
Since this is code golf, smallest code wins...
**EDIT**: To make this more challenging, you cannot use a language's built-in matrix operations libraries.
Also, your algorithm DOES NOT have to deal how to get the input, just how to process the input and return the correct output. As said before, you can store this input in whatever structure.
[Answer]
## Mathematica 40
Setting up the problem in your reference link:
```
s = {{2, 1, 1}, {1, -1, -1}, {1, 1, 1}};
r = {3, 0, 0};
```
The algorithm (spaces not needed):
```
i = 1; (a = s; a[[All, i++]] = r; Det@a/Det@s) & /@ r
```
result:
```
{1, -2, 3}
```
If the system has infinite solutions it returns `Indeterminate` or `ComplexInfinite`
Please note that Mathematica can solve linear systems natively. Among other possible ways you could use:
```
s~LinearSolve~r
```
or
```
Solve[s.{x,y,z}==r]
```
[Answer]
## Python3 - 310
```
def det(m,n):
if n==1: return m[0][0]
z=0
for r in range(n):
k=m[:]
del k[r]
z+=m[r][0]*(-1)**r*det([p[1:]for p in k],n-1)
return z
w=len(t)
d=det(h,w)
if d==0:r=[]
else:r=[det([r[0:i]+[s]+r[i+1:]for r,s in zip(h,t)],w)/d for i in range(w)]
print(r)
```
The determinant is calculated using Laplace's formula, nothing fancy :)
Supply the matrix and the known terms respectively in an array named h and t, like this
```
h = [[2, 1, 1],[1, -1, -1],[1, 2, 1]]
l = [3, 0, 0]
```
Which gives
```
[1.0, -2.0, 3.0]
```
[Answer]
# Matlab ~~(157)~~ ~~(155)~~(151)
I am not sure which parts of the program count for the score? (Currently only counting the algorithm, just as @belisarius did.)
```
%input
a = [1,2,3;4,5,6;7,4,2]
b = [1;3;4]
%algo
%%functiondefinition
function e = d(a)
z=length(a)
if z==1
e=a
else
e=0
w=2:z
for i=1:z
e=e-(-1)^i*a(1,i)*d([a(w,1:i-1),a(w,i+1:end)])
end
end
%%main
for i=1:numel(b)
c=a
c(:,i)=b
x(i)=d(c)/d(a)
end
%output
if any(isinf(d))
'no solutions'
elseif ~d(a)
'infinite solutions'
end
x
```
Matlab can of course solve linear systems natively:
```
a\b
```
] |
[Question]
[
## The Scenario
You are a taxi driver in your city. You picked up a passenger from the airport and he told you the place he'd like to go.
To earn more money, you need to drive as much as you can. However, there are two problems:
* He always looks around. Therefore, you cannot pass from the same district twice.
* The passenger is not so dumb. He knows the shortest way between the airport and the destination. Therefore, while you're driving, you should pass each of those districts.
## The Input
Input is an undirected and edge weighted graph. The vertices are the districts and the edges are the ways that connect those districts. The weights of the edges indicate the distance between the districts. You can model the graph any way you want.
## The Output
Given the source and destination, among with the shortest path, find the longest path that contains each vertex in the shortest path.
## The Example
**WHOOPS** there are two different edge weights between `B` and `C`.
**Source:** `A`
**Destination:** `K`
**Shortest Path:** `A-D-F-I-K`
**Solution:** `A-B-C-D-E-F-G-H-I-J-K`
Rules
1. Your solution should be generic and can be applicable to all kinds of connected graphs.
2. No cycles are allowed. You can pass through a vertex only once
3. Brute-force is not allowed. Don't list all the possibilities and pick among them.
4. The edge weights are always positive.
5. It is a must to visit all vertices in the shortest path, however, the order is not important.
Duration: 1 week.
Tie breaker: Votes.
The code with the least run-time complexity (in terms of Big-O notation) wins!
[Answer]
# Reduction to Traveling Salesman Problem, O(n^2\*2^n).
In the above, n is the number of vertices in the graph.
I will give a description of the algorithm for now. Starting with the input graph, carry out the following steps:
1. Create a new graph with edge weights equal to the negation of the input edge weights. These weights represent the value to the taxi driver of traversing those edges.
2. Let N be the sum of all of the negative weights in the (new) graph minus 1. Add N to each outgoing edge from a node on the shortest path (as given in the input). This represents the fact that the taxi driver absolutely must cross each vertex in the shortest path.
3. Now, use dynamic programming to solve the traveling salesman problem on this new graph as follows:
4. Next, create a memo table, m, with entries that are pairs, (v,S), where v is the final vertex in the (partial) path created so far, and S is a subset of the vertices in the graph. The weight associated with this entry will be the minimum sum of edge weights to reach v after having passed through the vertices in S. Also, maintain a parent pointer.
5. Initialize the memo table with the entry m[(source,{source}]=0, p[(source,{source}]=None.
6. Fill in the memo table, using the recursion that m[(v,S)] = min(m[(u,S-{v})]+w[(u,v)] for u in S), where w is the the edge weight dictionary. Create parent pointers accordingly.
7. Using the completed memo table, find the minimum value of m[(destination,S)], for all subsets S of the input vertices.
8. Trace the parent pointers from this minimum value backwards until we reach the source node. The resulting path is the solution.
I don't feel like coding that all up, but I believe it is a correct solution. It runs in `O(n^2*2^n)` time because there are n\*2^n entries in the memo table, and each is generated by taking a minimum over no more than n possibilities. All the other work takes far less than that amount of time.
This solves the problem because the traveling salesman path must go through all of the vertices on the shortest path, because skipping one of those vertices results in an increase in the traveling salesman cost of N, which cannot be offset by the negative edge weights in the graph, since N was chosen to be more negative than all of them combined.
] |
[Question]
[
You are to create a program, that, given another program, and a position, will make it a quine. Namely, it needs to insert an expression at that point that evaluates to a string that is the programs input. For example:
```
main=do
putStrLn "Welcome to the open source program, would you like my source code?"
(ans:_) <- getLine
case ans of
'y' -> putStrLn --Quine goes here
'n' -> putStrLn "Okay, Good bye"
_ -> putStrLn "Unrecongnized command. Try again." >> main
```
Now if I told it to put the source code at (5,24) the result would be.
```
main=do
putStrLn "Welcome to the open source program, would you like my source code?"
(ans:_) <- getLine
case ans of
'y' -> putStrLn ((\a b->a++(show a)++" "++(show b)++b) "main=do\n putStrLn \"Welcome to the open source program, would you like my source code?\"\n (ans:_) <- getLine\n case ans of\n 'y' -> putStrLn ((\\a b->a++(show a)++\" \"++(show b)++b) " ")--Quine goes here\n 'n' -> putStrLn \"Okay, Good bye\"\n _ -> putStrLn \"Unrecongnized command. Try again.\" >> main\n")--Quine goes here
'n' -> putStrLn "Okay, Good bye"
_ -> putStrLn "Unrecongnized command. Try again." >> main
```
Clarifications:
* The program you make and the type of programs it act upon may be different if you like.
* Your program may get the position in the program and its source code however it sees fit. You may put the new source code where ever you see fit.
* Obviously, the new program can't simply grab its source code from its file
* You may only insert things at the position the user specifies (so you may not be able to include any new modules in the new program depending on target language)
This is code golf, so shortest answer wins!
Let us see how many different languages we can make quine makers for as well.
[Answer]
# J - 73 char
Takes input on stdin, as the 0-origin index in characters and the source, separated by a newline. Introduces a copy of the program at the specified point as a string.
```
((".@{.~({.,}.,~'(',')',~(LF;''',LF,''')rplc~quote@])(}.~>:))i.&LF)1!:1]3
```
Explained by explosion:
```
( )1!:1]3 NB. stdin
( )i.&LF NB. find the first newline
{.~ NB. the index part of input
".@ NB. convert index to integer
(}.~>:) NB. the source program part
({.,}.,~ ) NB. program before and after index
...@] NB. program quoted properly
```
For example, given input
```
3
abcdef'ghij'
kl mn 0p1
```
the output is
```
abc('abcdef''ghij''',LF,'kl mn 0p1')def'ghij'
kl mn 0p1
```
because J uses Pascal-style strings: `'Isn''t this great?'`
[Answer]
## Haskell (390 Char)
```
import System.Environment
import Data.List
main = do
[p] <- getArgs
interact $ q (read p)
q :: (Int, Int) -> String -> String
q p j=case d p j of
(f, s) -> b (f++i) (')':s)
d (l,c) j=case splitAt (l-1) (lines j) of
(f, (t:s)) -> case splitAt c t of
(r,y) -> ((unlines f)++r, y++"\n"++(unlines s))
b=(\a b->a++(show a)++" "++(show b)++b)
i="((\\a b->a++(show a)++\" \"++(show b)++b) "
```
Not very golfed. Just an example. This takes the position as a command line argument and source code as a standard input and puts the new source code as standard output.
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/24724/edit).
Closed 9 years ago.
[Improve this question](/posts/24724/edit)
Create a program which gets an input from the user and tells the user what repetitions exist in the it. A few examples of inputs the user could give and outputs they should get:
>
> Input: 112211221122
>
>
> Output: 1122 \* 3
>
>
>
Or:
>
> Input: 123123
>
>
> Output: 123 \* 2
>
>
>
Or:
>
> Input: 1234
>
>
> Output: No repetitions found!
>
>
>
Tiebreaker: if your code can recognize more than one repetition:
>
> Input: 123123456456
>
>
> Output: 123 \* 2, 456 \* 2
>
>
>
Then you win if you are tied for 1st place with someone's code who doesn't recognize more than one repetition.
If your code requires a limit on the repetition length, it should be able to recognize repetitions at least 4 characters long. This is a code-golf question, so the shortest code wins (but please explain the code in your answer)
[Answer]
# Perl, 74 (73 + 1) bytes
* Assumes `-n` flag (+1 byte).
* `say` is a feature of version 5.10 and needs to be enabled.
This can be done by flag `-M5.010` or easier with `-E` instead of `-e`.
Therefore I follow the other Perl [answer](https://codegolf.stackexchange.com/a/24725/16143) in the calculation method of the costs.
* It also reports repetitions as long as they do not overlap.
```
s/(.+)(?{$i=1})(\1(?{$i++}))+/say"$1 * $i"/ge||say"No repetitions found!"
```
## Usage and tests
```
echo 112211221122 | perl -nE 's/(.+)(?{$i=1})(\1(?{$i++}))+/say"$1 * $i"/ge||say"No repetitions found!"'
1122 * 3
```
```
echo 123123 | perl -nE 's/(.+)(?{$i=1})(\1(?{$i++}))+/say"$1 * $i"/ge||say"No repetitions found!"'
123 * 2
```
```
echo 1234 | perl -nE 's/(.+)(?{$i=1})(\1(?{$i++}))+/say"$1 * $i"/ge||say"No repetitions found!"'
No repetitions found!
```
```
echo 123123456456 | perl -nE 's/(.+)(?{$i=1})(\1(?{$i++}))+/say"$1 * $i"/ge||say"No repetitions found!"'
123 * 2
456 * 2
```
## Ungolfed with comments
```
s/
(.+) # catches the repeat unit
(?{ $i=1 }) # initialize counter $1 with 1
(
\1 # next repetition
(?{ $i++ }) # increase counter
)+ # repeat unit must appear at least twice
/
say "$1 * $i" # print result as a side effect of the replacement;
# "say" adds a new line at the end
/gex # g: global, find all repetitions (without overlap)
# e: replacement text is executed as code
# x: only ungolfed: readability and comments
|| # s/// returns the number of replacements,
# this is zero, if no repetitions could be found
say "No repetitions found!"
```
[Answer]
# JavaScript, 81
Assumes input is stored in variable `s`. Run this in a console.
```
x=s.match(/^(.+?)\1+$/)
x?x[1]+" * "+s.length/x[1].length:"No repetitions found!"
```
Does not support multiple repetition, but that is portrayed as optional.
Explanation: regex `/^(.+?)\1+$/` matches one or more characters and then those characters repeated one or more times. `?` is used to make the `+` lazy, so it works for `123123123123`.
[Answer]
# Perl (85 + 1 = 86 bytes)
Assumes `-n` flag (+1 byte) and `-M5.010` (free).
```
length>4&&($i=say"$1 x ",length($&)/length$1)while/(.+)\1+/g}{$i||say"No repetitions found!"
```
Sample:
```
~ $ echo 123123456456 | perl -nE 'length>4&&($i=say"$1 x ",length($&)/length$1)while/(.+)\1+/g}{$i||say"No patterns found!"'
123 x 2
456 x 2
~ $ echo 112211221122 | perl -nE 'length>4&&($i=say"$1 x ",length($&)/length$1)while/(.+)\1+/g}{$i||say"No patterns found!"'
1122 x 3
```
[Answer]
# APL 71 characters
```
(1+B<S)⌷(⊂'no repetitions found!'),⊂W[B],S÷B←1⍳⍨∧/¨V=¨S⍴¨W←V↑⍨¨⍳S←⍴⊃V←⊂
```
Example:
```
(1+B<S)⌷(⊂'no repetitions found!'),⊂W[B],S÷B←1⍳⍨∧/¨V=¨S⍴¨W←V↑⍨¨⍳S←⍴⊃V←⊂ '123123'
```
Try it with my online compiled to javascript version of GNU APL: [here](http://baruchel.hd.free.fr/apps/apl/#code=%E2%8E%95%E2%86%90%27Example%201%3A%20%22123123%22%27%0A%281%2BB%3CS%29%E2%8C%B7%28%E2%8A%82%27no%20repetitions%20found!%27%29%2C%E2%8A%82W%5bB%5d%2CS%C3%B7B%E2%86%901%E2%8D%B3%E2%8D%A8%E2%88%A7%2F%C2%A8V%3D%C2%A8S%E2%8D%B4%C2%A8W%E2%86%90V%E2%86%91%E2%8D%A8%C2%A8%E2%8D%B3S%E2%86%90%E2%8D%B4%E2%8A%83V%E2%86%90%E2%8A%82%20%27123123%27%0A%E2%8E%95%E2%86%90%27Example%201%3A%20%22121212%22%27%0A%281%2BB%3CS%29%E2%8C%B7%28%E2%8A%82%27no%20repetitions%20found!%27%29%2C%E2%8A%82W%5bB%5d%2CS%C3%B7B%E2%86%901%E2%8D%B3%E2%8D%A8%E2%88%A7%2F%C2%A8V%3D%C2%A8S%E2%8D%B4%C2%A8W%E2%86%90V%E2%86%91%E2%8D%A8%C2%A8%E2%8D%B3S%E2%86%90%E2%8D%B4%E2%8A%83V%E2%86%90%E2%8A%82%20%27121212%27%0A%E2%8E%95%E2%86%90%27Example%201%3A%20%22123456%22%27%0A%281%2BB%3CS%29%E2%8C%B7%28%E2%8A%82%27no%20repetitions%20found!%27%29%2C%E2%8A%82W%5bB%5d%2CS%C3%B7B%E2%86%901%E2%8D%B3%E2%8D%A8%E2%88%A7%2F%C2%A8V%3D%C2%A8S%E2%8D%B4%C2%A8W%E2%86%90V%E2%86%91%E2%8D%A8%C2%A8%E2%8D%B3S%E2%86%90%E2%8D%B4%E2%8A%83V%E2%86%90%E2%8A%82%20%27123456%27).
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/22398/edit).
Closed 9 years ago.
[Improve this question](/posts/22398/edit)
Write a program to output the part of speech of any word inputted to it. I doubt that anyone could get a perfect algorithm, so I will give the code a batch of words in order to ascertain what algorithm is the best.
Weighted Scoring:
+10pts for each word identified correctly: <http://www.englishclub.com/grammar/parts-of-speech_1.htm> (out of 100 randomly selected words)
-1pt for each byte
+5pts for each upvote on your answer
Rules:
no using external resources (unless they are counted in the size)
UPDATE: Due to the need for a standardized word list for testing purposes, I will be using the list provided in the response to this question. <http://www-personal.umich.edu/~jlawler/wordlist> It seems to be a fairly complete list, and will make this a challenge more than a guessing game.
[Answer]
# Mathematica
Mathematica has a native database of words (called up by the simple command `WordData` ) that includes, among other properties, the parts of speech. Without this database, it would be impossible for me to answer the question.
The word list from [here](http://www-personal.umich.edu/~jlawler/wordlist) was downloaded.
Once stored, it is called up as follows:
```
words = Import["wordlist.txt", "Table"];
Length[words]
```
>
> 69905
>
>
>
Forty words are randomly chosen from the list:
```
list = Flatten@RandomSample[words, 40]
```
>
> {"mealtime", "deride", "cricketground", "torpedinidae", "rosefish",
> "akron", "sloppy", "deaden", "assaultive", "mick",
> "unperceptiveness", "skeg", "pad", "mane", "carvel-built",
> "night-stop", "monarchy", "corking", "backlog", "scaphopoda",
> "bagman", "phrthe", "wholesome", "proprietress", "hortus",
> "unreliable", "farthermost", "fearfulness", "malposed", "stoke",
> "affiche", "lunatic", "holcus", "devoutness", "macaque", "zenithal",
> "poetry", "precipitate", "agoraphobic", "snapper"}
>
>
>
---
The following asks Mathematica to return the parts of speech for the list of 40 words.
The parts of 31 words are identified. 9 words are not recognized.
```
(s = Select[Flatten@{{#}, WordData[#, "PartsOfSpeech"]} & /@
list, ! MatchQ[#, {_, WordData[_, _]}] &]) // TableForm
Length[s]
```
] |
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
Questions without an **objective primary winning criterion** are off-topic, as they make it impossible to indisputably decide which entry should win.
Closed 1 year ago.
[Improve this question](/posts/11870/edit)
[This](https://stackoverflow.com/q/17120798/171916), but via template metaprogramming:
```
template <int n> struct insanity { int[][n] permutations; }
```
Generate all numbers with n digits (0-9) such that each digit is either:
1. Zero
2. The first digit
3. Already present
4. Greater than the maximum digit to the left
Don't worry about leading zeros either way.
Valid examples:
```
012333
012391
```
Invalid examples:
```
012945
```
(Is this even possible?)
Winning code will be explainable and concise, but I'll take a clear short answer over the shortest.
Clarification on conditions: Shortest code with a complete explanation for what's going on. "Complete" means: Explain it to someone who knows how templates work, but not how TMP works.
[Answer]
Success!!!! It only took me 3 hours or so. (Note: Requires C++11 support)
## 4,410 characters (including output functions)
### Compiled on GCC 4.7.2 ([Ideone](http://ideone.com/D0sZrj))
```
#include<iostream>
#include<type_traits>
int constexpr powOf10(size_t power)
{
return power == 0 ? 1 : 10 * powOf10(power - 1);
}
template<int... digits>
struct buildNumber;
template<int first, int... digits>
struct buildNumber<first, digits...> : std::integral_constant<int, first * powOf10(sizeof...(digits)) + buildNumber<digits...>::value>
{
};
template<>
struct buildNumber<> : std::integral_constant<int, 0>
{
};
template<int... digits>
struct areAllDigits;
template<int first, int... digits>
struct areAllDigits<first, digits...>
{
static bool constexpr value = first > 0 && first < 10 && areAllDigits<digits...>::value;
};
template<int first>
struct areAllDigits<first>
{
static bool constexpr value = first>0 && first < 10;
};
template<class T>
struct buildNumberT;
template<int... digits>
struct digitContainer
{
};
template<int... digits>
struct buildNumberT<digitContainer<digits...>> : buildNumber<digits...> {};
template<class T1, class T2>
struct concatCtr;
template<int... digits1, int... digits2>
struct concatCtr<digitContainer<digits1...>, digitContainer<digits2...>>
{
typedef digitContainer<digits1..., digits2...> type;
};
template<int number, size_t digit>
struct breakIntoDigits
{
typedef typename concatCtr<digitContainer<number / powOf10(digit)>, typename breakIntoDigits<number % powOf10(digit), digit - 1>::ctr>::type ctr;
};
template<int number>
struct breakIntoDigits<number, 0>
{
typedef digitContainer<number> ctr;
};
template<int needle, int... haystack>
struct contains;
template<int needle, int first, int... haystack>
struct contains<needle, first, haystack...>
{
static bool constexpr value = needle == first || contains<needle, haystack...>::value;
};
template<int needle>
struct contains<needle>
{
static constexpr bool value = false;
};
template<int... values>
struct max;
template<int first, int... rest>
struct max<first, rest...>
{
static constexpr int value = first > max<rest...>::value ? first : max<rest...>::value;
};
template<>
struct max<>
{
static int constexpr value = 0;
};
template<class container, int... digits>
struct ruleChecker;
template<int current, int... allPrevious, int... rest>
struct ruleChecker<digitContainer<allPrevious...>, current, rest...>
{
static bool constexpr value = (current == 0 || sizeof...(allPrevious) == 0 || contains<current, allPrevious...>::value || current > max<allPrevious...>::value) && ruleChecker<digitContainer<allPrevious..., current>, rest...>::value;
};
template<class container>
struct ruleChecker<container>
{
static bool constexpr value = true;
};
template<class ctr1, class ctr2>
struct ruleCheckerT;
template<class ctr1, int... set2>
struct ruleCheckerT<ctr1, digitContainer<set2...>> : ruleChecker<ctr1, set2...>{};
template<int number, int length>
struct isValidNumber : ruleCheckerT<digitContainer<>, typename breakIntoDigits<number, length>::ctr>
{
};
template<int number, int length>
struct generateList
{
typedef typename std::conditional<number % powOf10(length) == 0,
digitContainer<>,
typename concatCtr<
typename generateList<number + 1, length>::container,
typename std::conditional<isValidNumber<number, length>::value,
digitContainer<number>,
digitContainer<>
>::type
>::type
>::type container;
};
template<int number>
struct generateList<number, 1>
{
typedef typename concatCtr<
typename generateList<number + 1, 1>::container,
typename std::conditional<isValidNumber<number, 1>::value,
digitContainer<number>,
digitContainer<>
>::type
>::type container;
};
#define DEFINE_ENDPOINT_FOR_LENGTH(length) template<> struct generateList<powOf10(length), (length)>{typedef digitContainer<> container;}
template<int length>
struct insanity
{
static_assert(length > 0, "Length must be greater than 0.");
typedef typename concatCtr<typename generateList<1, length>::container, digitContainer<0>>::type numberList;
};
template<int first, int... rest>
void outputContainer(digitContainer<first, rest...> values)
{
std::cout<<first<<'\n';
outputContainer(digitContainer<rest...>{});
}
void outputContainer(digitContainer<> empty)
{
std::flush(std::cout);
}
```
## Explanation
`insanity` is the entry point, as used in the OP. `buildNumber` builds a number from a list of digits; `breakIntoDigits` does the opposite; it takes a number and breaks it into `length` digits. `areAllDigits` is just a helper I used earlier. It isn't used in the final code. It's `value` property is true if all the numbers passed to it are base-10 digits. It generates a list of valid numbers (validated by `isValidNumber`) and puts them in a `digitContainer` (originally I was only going to use this for digits, but I decided to use it for both things).
## Limitations
* It can only calculate up to the point the compiler errors out from template recursion depth.
* You need to define an ending point for each length because otherwise it keeps instantiating templates up to the limit because of std::conditional. You define an ending point for each length by typing `DEFINE_ENDPOINT_FOR_LENGTH(i)` where `i` is the length.
] |
[Question]
[
A Web Crawler is a program that starts with a small list of websites and gets the source code for all of them. It then finds all the links in those source codes, gets the website it links to then puts them in a list. It then starts again but with the new list of websites.The main reason for a Web Crawler is to find all (or most) of the websites in the internet. Google use this to power their search engine.[Wikipedia Page about Web Crawlers](http://en.wikipedia.org/wiki/Web_crawler)
Your task is to create a Web Crawler in any language you wish.
**Rules**
>
> * Your first list can contain any amount of websites <= 5 and any websites you wish.
> * Your web crawler can ignore any websites with the HTTP GET request or any other pages other than the home page, e.g. www.somewebsite.com/?anything=1 and www.somewebsite.com/secondpage can be ignored, we are only trying to find the website/domain, e.g. www.somewebsite.com
> * You can use any method you wish to store the list of websites currently being "crawled".
> * Although this is code golf, the highest voted answer/solution will win, and don't forget to have fun!
>
>
>
[Answer]
**Javascript, 491**
Golfed
```
var C=function(c){w=c.length;for(i=0;i<w;i++){var b=new XMLHttpRequest;b.setRequestHeader("Access-Control-Allow-Origin","*");b.setRequestHeader("X-Requested-With","XMLHttpRequest");b.open("GET",c[i],!0);b.send();if(200===b.status){a=b.responseText.match(/\<[(a|img)]+\s[^\>]+[(http|https)]+:\/\/([\w\.])+([.])+.+?[^.]+?./gi);u=c[i].substr(7);re=RegExp(u,"i");for(j=0;j<a.length;j++)if(a[j].match(re)&&(b=a[j].match(/[(http|https)]+:\/\/([\w\.])+([.])/gi))&&!c.indexOf(b))c.push(a[j]),w++}}};
```
Un-Golfed
```
var C = function(s){
w = s.length;
for(i = 0; i < w; i++){
var r = new XMLHttpRequest();
r.setRequestHeader("Access-Control-Allow-Origin", "*")
r.setRequestHeader("X-Requested-With", "XMLHttpRequest");
r.open('GET', s[i], true); r.send();
if(r.status === 200) {
a = r.responseText.match(/\<[(a|img)]+\s[^\>]+[(http|https)]+:\/\/([\w\.])+([.])+.+?[^.]+?./gi);
u = s[i].substr(7),
re = new RegExp(u,'i');
for(j = 0; j < a.length; j++){
if(!a[j].match(re)) continue;
var uri = a[j].match(/[(http|https)]+:\/\/([\w\.])+([.])/gi);
if(uri && !s.indexOf(uri)) {
s.push(a[j]); w++;
}
}
}
}
}
```
Method
```
var c = new C(['http://www.cnn.com', 'http://www.usatoday.com', 'http://www.huffingtonpost.com', 'http://www.drudgereport.com/', 'http://news.cnet.com']);
```
] |
[Question]
[
# King of the Cards
*Code available [here](https://gist.github.com/GingerIndustries/7c2ea84cb7cb38307382892b1529a777)!*
In this King of the Hill challenge, you must write a bot that can play [Crazy Eights](https://en.wikipedia.org/wiki/Crazy_Eights). This is a card game often played by children, in which the objective is to empty your hand.
## How to Play
The game of Crazy Eights is deceptively simple. At the beginning of the game, each player gets dealt a hand of cards (in this case eight), with the remaining cards placed in the middle of the table as the draw pile. The top card is then placed face up and serves as the beginning of the discard pile. Then, each player can discard one card per turn if that card has a matching suit or rank with the top card on the discard pile. They may also play an 8, which allows them to change the effective suit of the 8 and therefore the suit the next player must follow. The played card then becomes the top card. If the player does not have any matching cards, they must draw from the draw pile until they get a matching card and play that. If they exhaust the draw pile, play passes to the next player. Players may draw at any time, even if they have playable cards (which does not count as a turn).
For example, if 6♣ is played, the next player:
* Can play a 6 of any suit
* Can play any club
* Can play an 8 (and then must declare a suit)
* Can draw and continue their turn.
If the draw pile runs out, then the discard pile (except for the top card) is shuffled and becomes the new draw pile.
The game ends once a player runs out of cards, in which case they are declared the winner. (This differs from normal Crazy Eights, and is included to make this game a bit simpler.)
# Bots
Bots must be written in Python. Bots will have access to the `kotc` module, which supplies these classes:
* `KOTCBot`, which bots must extend
* `Card`, which represents a card
* `Suit` and `Rank`, enums representing the suit and value of a card
Bots must implement a `play` method, which takes as input a `Card` representing the top card on the discard pile. This method must return a `Card` within that bot's `hand`. If the returned `Card` is not in the bot's `hand` that bot is disqualified. (I will leave a comment on it with information about the state of the game when it happened.) However, if the `Card` is an `Eight` then only the `rank` will be checked against the bot's `hand`. If the bot has no playable cards in its hand, the `play` method will ***NOT*** be called and the controller will automatically draw cards on behalf of the bot and add them to its `hand`. **The bot should NEVER modify its `hand`!** This will be done by the controller. The `play` method may also return `None` or `False`, which will cause its turn to be skipped.
Bots will compete against each other in matches of two, in an elimination-style tournament bracket. The winner will advance onwards, and the loser will be ~~executed~~ eliminated.
# API
## `KOTCBot`
This class is the actual bot.
Methods and properties: (Do NOT override any of these in your bot)
* `draw`: When called, this function draws a card from the pile and adds it to the bot's hand. It also returns the card drawn.
* `hand`: This property is a list of `Card`s representing the bot's hand.
* `arena`: This property is the `KOTCArena` instance the bot is playing in.
## `KOTCArena`
This class is accessible through the `arena` property of the `Bot`. It has three functions available to the bots:
* `handSizes`: Returns a list of the lengths of the hands of the other bots
* `discardSize`: Returns the size of the discard pile
* `drawSize`: Returns the size of the draw pile
## `Card`
The `Card` class represents a card, and takes a `Suit` and `Rank` when constructed. This class must be returned by the bot's `play` method. Its suit and rank can be accessed through their respective properties.
* `all`: This classmethod takes no parameters and returns a 52-item list of all possible card combinations.
*Note: All enumeration members are UPPERCASE.*
## `Suit`
Members of this enum:
* `CLUBS`
* `DIAMONDS`
* `SPADES`
* `HEARTS`
## `Rank`
Members of this enum:
* `ACE`
* `KING`
* `QUEEN`
* `JACK`
* `TWO` through `TEN`
# Example Bot
This bot just plays any available card, without using eights.
```
import kotc
class ExampleBot(kotc.KOTCBot):
def play(self, discard):
for card in self.hand:
if card.suit == discard.suit or card.rank == discard.rank:
return card
```
[Answer]
# BasicBot
```
import kotc
from random import shuffle
class BasicBot(kotc.KOTCBot):
shuffle(self.hand)
def play(self, discard):
for card in self.hand:
if (card.rank == kotc.Rank.EIGHT):
playables = 0
for card2 in self.hand:
if card.suit == discard.suit or card.rank == discard.rank:
playables+=1
if playables<2:
return card2
if card.suit == discard.suit or card.rank == discard.rank:
return card
for card in self.hand:
if card.suit == discard.suit or card.rank == discard.rank:
return card
```
I think this will work. Pretty much ExampleBot, except it will play an eight if it has less than two other cards it can play. Currently doesn't prioritize playing a specific suit (that's next on my list of goals) but it still should be better than BasicBot.
] |
[Question]
[
I've been doing quite a few code golf recently and I realised that a lot of times, I have to do something involving list.
Most of the times lists are space-separated or comma-separated values in the first argument (`argv[2]`), and the return value should also be a space/comma-separated string.
Are there any tips for converting comma/space-separated to array and back to comma/space-separated values ?
Here's what I know so far:
### Array => String
```
["foo","bar","baz"].join() // Default argument is ","
["foo","bar","baz"].join` ` // ES6 backtick syntax
["foo","bar","baz"]+"" // Equivalent of toString(): return comma-separated values
```
### String => Array
```
"foo,bar,baz".split`,` // ES6 backtick syntax
```
So are they other shorter ways of doing it or problem-specific solutions that doesn't require conversion from string to array and back to string ?
[Answer]
## `eval`
For array of numbers, `eval` may work.
```
s.split(',')
eval(`[${s}]`)
```
Although code above is a bit longer, but there are some extra benefits via `eval`:
* `eval` returns `number[]` instead of `string[]`, and you can add them easier.
* `eval` provide an extra `()` pair. You may write some codes in the `eval` string, in the `eval` brackets, and also after the `eval`.
[Answer]
## String.prototype.replace
If you want a simple `Array#map`, you may use `String#replace` instead.
```
s.split`,`.map(v=>f(v))+'' // comma split and join
s.replace(/[^,]+/g,v=>f(v)) // comma separated
s.replace(/\w+/g,v=>f(v)) // comma separated
s.split` `.map(v=>f(v)).join` ` // space split and join
s.replace(/\S+/g,v=>f(v)) // space separated
```
`String#replace` may be shorter if you can find a short RegExp. `/[^,]+/` is a bit longer, but if `/\w+/` is acceptable, it could be shorter.
But be notice that the 2nd parameter of replace callback is the position by character instead of position in array.
You may also use some capture groups to parse the string in it.
] |
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
This question does not appear to be about code golf or coding challenges within the scope defined in the [help center](https://codegolf.stackexchange.com/help/on-topic).
Closed 2 years ago.
[Improve this question](/posts/204956/edit)
Is there a programming language that supports single tape Turing machines specified in some format?
I am aware multiple formats for expressing them exist, but is there a standard one using which an acceptable answer can be published on this site?
If it doesn't exist can somebody create one? Golfing Turing machines has academic relevance too.
[Answer]
It should be acceptable to post answers in pure turing machine code. I have seen people do this before.
Examples:
<https://codegolf.stackexchange.com/a/200380/95627>
[Simple cat program](https://codegolf.stackexchange.com/questions/62230/simple-cat-program/193623#193623)
If anyone knows more about this, you can edit.
[Answer]
[I’ve made one.](https://gitlab.com/Tom_Fryers/turma)
It’s an interpreter written in Python, so it’s not ideal for anything intensive, but the source format is fairly concise for golfing. It uses Unicode characters as tape symbols.
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/186495/edit).
Closed 4 years ago.
[Improve this question](/posts/186495/edit)
JonoCode9374 had almost completely implemented my language [EnScript](https://esolangs.org/wiki/Talk:EnScript) except for the CHS command. I was impatient of waiting for them to implement this command, so I chose to put this question here.
## Challenge:
Write a solution that takes an input and returns the chased output. Standard [loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) are forbidden.
This is the CHS instruction reference copied from the website:
>
> CHS means to chase all of the numbers inside an accumulator.
>
>
> Chasing a number means to move a number forward inside the accumulator that-number of times.
>
>
>
Chasing an accumulator means to move all of the numbers inside an accumulator from the lowest number (0) to the highest number (9) **sequentially**, without repeating. **Sequentially means: the values are moved in a sequential order that was presented in the accumulator, which is from left to right.**
* **Here is an important note:** The number is still there while the number is moved, and that number will be removed from the original number if and only if the currently chased number has been put in place.
* **Here is an extra note:** A number with the lower magnitude should be "chased" first in the accumulator. For example, the number 1 should be chased prior to the numbers 2, 3, 4, etc.
* **One more note:** Accumulators should be unbounded, i.e. without an upper limit. Also, they cannot and **should not** support negative numbers. The implementation does not have to detect that; it can assume that the input is valid.
* The type of the accumulators should be in the unbounded integer form; The value of an accumulator should not be a floating-point integer.
* If zeroes are in front of the number at the end of the process, they are deleted by default.
## Examples:
* Take A=123 as an example.
* Value `1` will move forward 1 number. (It will be inserted behind `2`.) So, the number will be `213`. 1 will be marked as chased.
* Likewise, `2` will also be moved. It will be moved forward twice, so the number will be `132`.
* `3` will also be chased. It will move forward 1 time (finding that the end of the list is reached), and then it will go to the place before `1`. Then, it will go back to where it was.
* Accumulator A "chased" will be `132`.
Also, take `3112` as an example, which is quite vague. Some people may ask: which '1' gets "chased" first?
Answer: The first '1' from left to right gets "chased" first. See the notes from above.
So, the chase after 1 iteration will be:
31121324→31131224
Another example. 10 will be chased to 01, as 0 cannot be moved and 1 will be moved for 1 digit. Then, this preceding 0 will be deleted, leaving a 1 to the accumulators.
## Test Cases:
```
123 -> 132
12345 -> 14253
3141 -> 3141
123123 -> 312132
94634 -> 96434
1277 -> 7172
10 -> 1
```
Please comment for me if this question is too vague!
[Answer]
# Python 3, ~~262~~ ... 170 bytes
This program outputs the result via Stderr.
I'm a bit out of practice at golfing, since I have not been too active lately, so I'm sure it can be golfed more.
```
L=[[c,int(c)]for c in input()]
while 1:i=L.index(min([x for x in L if x[1]]or exit(str(int("".join(x[0]for x in L))))));L[i][1]-=1;q=i+1<len(L)and-~i;L.insert(q,L.pop(i))
```
[**Try it online**](https://tio.run/##RY1BDsIgFET3noJ09YltI3Zn5QbcgLAwLU2/qR/aYsSNV0dw42RWkzcz/h1mR11KSmo91EgBBm4mt7GBIWX7ZwBuDq8ZF8vEBaVqkUYb4YEEOrKCxoIqhhOLWhiTExsxwB42KINV1d5dpqM@mT/Of@qVRpNLjRT9KvEoroslUPxGY/PBvpztdguw1qr1zgNynpI4d9lf)
### Ungolfed
```
# Index to shift, Times remaining
def Shift(i, t):
if t<1:
L[i][1]=0
return
if i+1<len(L):
L[i],L[i+1]=L[i+1],L[i]
Shift(i+1,t-1)
else:
L.insert(0,L.pop())
Shift(0,t-1)
L=[[c,1]for c in input()]
while 1:
t=[x for x in L if x[1]]or exit("".join(x[0]for x in L).lstrip('0'))
i=L.index(min(t,key=lambda x:x[0]))
Shift(i,int(L[i][0]))
```
] |
[Question]
[
# Goal
Given a deal result from [Duplicate Contract Bridge](https://en.wikipedia.org/wiki/Contract_bridge), calculate the deal [score](https://en.wikipedia.org/wiki/Bridge_scoring#Scoring_elements).
Basically the same as [iBug](https://codegolf.stackexchange.com/users/71806/ibug)'s question, which was deleted. I figured out this scoring system while trying to answer that question.
### Input
Input is a deal result, and whether or not the declaring side is vulnerable.
The **deal result** is a string in the following format:
```
[contract] [result]
```
The contract is defined as follows:
```
[tricks][suit][doubling]
```
* The `tricks` is a number `1-7` (both inclusive),
* The `suit`is one of `C`, `H`, `S`, `D`, or `NT` (Clubs, Hearts, Spades, Diamonds, and notrump)
+ Suits are grouped as follows: `notrump: NT`, `Major suits: H, S` and `Minor suits: C, D`.
* `doubling` can be *blank* , `X` or `XX` (Undoubled, Doubled, Redoubled)
`result` is the resulting number of 'tricks' in relation to the contract. The value can be in the range `[-13; +6]`, depending on the `value` (sign included).
The sum of `contract number` and `result` must be in the range`[-6; 7]`, which means:
* For `tricks= 1`, `result` must be `[-7; +6]`
* For `tricks= 2`, `result` must be `[-8; +5]`
* ..
* For `tricks= 7`, `result` must be `[-13; 0]`
**Examples of valid deal results:**
`1S 0`, `4NT -3`, `7NTXX -13`, `3HX +3`
---
**Vulnerability** can be input as a boolean or any *truthy/falsy* value.
### Output
Output is the scoring of the deal result.
The score is based on the number of tricks in a deal, and whether it reached the contract.
---
# Scoring
The score is a measure of the result compared to the contract.
If the contract is made, the score for each such deal consists of:
* Contract points, assigned to each trick bid and made
* Overtrick points, assigned for each trick taken over the contracted number of tricks
* A slam bonus for a small slam or grand slam contract
* A doubling bonus
* A game bonus
If the contract is defeated, the defenders receive
* Penalty points, assigned for every undertrick (negative value of `result`)
---
### Contract points:
Contract points are awarded for the tricks of the contract.
```
Points per trick
Suit undoubled doubled redoubled
------------------------------------------------------------
Notrump
-first trick 40 80 160
-subsequent tricks 30 60 120
Major suits 30 60 120
Minor suits 20 40 80
```
### Overtrick points:
Overtrick points are awarded for the tricks made, more than the contract (`result` > `0`)
```
Points per trick
Suit vulnerable not vulnerable
If undoubled:
Notrump 30 30
Major suits 30 30
Minor suits 20 20
Doubled (per trick) 200 100
Redoubled (per trick) 400 200
```
### Slam bonus
If a large contract is made, it earns a slam bonus:
* `tricks = 6` earns a bonus of `500` if not vulnerable, and `750` if vulnerable
* `tricks = 7` earns a bonus of `1000` if not vulnerable, and `1500` if vulnerable
### Doubled or redoubled bonus
If a doubled or redoubled contract is made, a bonus is earned:
* `50` points for a doubled contract
* `100` points for a redoubled contract
### Game bonus
A game bonus is awarded based on the contract points.
* Contract points below `100` earns a bonus of `50`points.
* Contract points `>= 100` earns a bonus of `300` if not vulnerable, and `500` if vulnerable
---
### Penalty
Each undertrick (negative `result`) gives a penalty point.
No points are ganied for the contract, as it was failed.
```
Points per undertrick
vulnerable not vulnerable
undoubled doubled redoubled undoubled doubled redoubled
1st undertrick 100 200 400 100 100 200
2nd and 3rd, each 100 300 600 100 200 400
4th and subsequent 100 300 600 100 300 600
```
---
## Examples:
Deal result: `4DX +1`, Vulnerable=`true`:
* Contract points = `4*40 = 160`
* Overtrick points = `1*200 = 200`
* Slam bonus = no bonus
* (re)doubled bonus = `50`
* Game bonus = `500` (`140>=100`and vulnerable)
**Result =** `160+200+50+500 =` **`910`**
---
Deal result: `6NTXX 0`, Vulnerable=`false`:
* Contract points = `4*40 = 160`
* Overtrick points = `1*200 = 200`
* Slam bonus = no bonus
* (re)doubled bonus = `50`
* Game bonus = `500` (`140>=100`and vulnerable)
**Result =** `160+200+50+500 =` **`910`**
---
Deal result: `4SX -3`, Vulnerable=`false`:
* Penalty = `1*100 + 2*200 = 500`
**Result = `-500`**
---
Deal result: `7SNTXX -13`, Vulnerable=`true`:
* Penalty = `1*400 + 2*600 + 10*600 = 7600`
**Result = `-7600`**
---
# Example Input/Output:
Input is guaranteed to be valid.
```
1S 0 (non-vul) # => 80
3NT +1 (non-vul) # => 430
3NT +1 (vul) # => 630
6CX +1 (vul) # => 1740
4D -1 (vul) # => -100
7NTXX -13 (vul) # => -7600
```
---
Results can be checked against [these tables](http://rpbridge.net/cgi-bin/xsc1.pl).
I've also included a [TIO](https://tio.run/##xZffb9s2EMefp7@CRRBIspiCpH47VfcQZwgwoAGczNhg@CGNnTVAZQeyE7Qo1n89uztSpOzIqfcwFAYZ5UhR/PDuvjo9fN18Wi3V8339sGo2rFl488Ud@y144ms@5zWfhEOPXVXCY/d3rH4nhs1i89gsg@Dke30yCQdxJKPvk0F98yUQvI5UGA7mAykEWzUsFYN6EMhoEtLda3a/9M9GPizImmrq/TKdcXbEfoWLXPBScCmhxdBSaGCSpaAZEma8MqxgeN9YjGM99gTsiRA8UdASbUvxMfB/af7P8N52MIdNMzabPs3gAmAmQzK0HD@LIQOGDPacdRhkjJPi0lEouYdiXlWSQDocMJcraHFCR8PThJbnuV4DQWQBU6DF0BJoKbSsoGEESeD5KbQMWg6tyGkIOVJgzKDl0ApJZsRIAS2DlqdkIgpBx6UpyBVZTNdbDP2ukGb7qd42ehSWwi7ehojN5nNoZYGTHEWmd86lwE5hlzgQBCjRYdprDgUQeImekh0W3Ig0B0gOiXtYtD/Urj8UuD6BBvi8wDAQ2KFVJrGlSTOggFZm@GjsYuzAbHlgDwXuQ2CHHm6Dm3gw8BXei12sLE8h8BbslHBAeHAyLZxzyuxQ5yjDojmQTCKWQrvKHFFuSZANH8AVMqncMRUWBemUoNB1UKVhgbOHTklHpYlQAcDjDqvdiPVT9hKrVbKLqz4lK0yOJzpX4cy4BnMy8Nq4MtHbN4ZEpFepyTrZ0bIdG2kZ7kXIjpi1oz8Ws/8ZgyQrJdFAKXBytmMjp1CIJFlHzpT8D3KW0aM5hg4swjGYMp0sbaT16BUvcxtkqQnY3CRgGTs5A43KoOXQitJGl5EyXnQkQHV0gpyR5wfLmdl@b463EP1yBYnhQHK9ebgXu5heKY4FGUqjufb1QQqAaiawUx0ePENZZC5VkvxgSUvB/S8EBzZjMtUi9SoW5bpF2it5iFRQBmCHbyuZFDv5r4wIOCjcQaEclEoOdVJuWQgD0RRSKRyIpaPao1nwQnVYpaVBQEUx3OHSTJjvEhGV6oARE5YFcGHBFAZF6yECK5NeYasq/0OfrJV0WroEwSdKXSOovKMHr4yrttyKdRImsF6qOrLWYydZ27GRrOFehOrKmtona1fVVHD8KeEaamUOZwPzBsH8nQxfEY/@QgfrBSseuL1tGcA0suLhKhuUAywNWi926iAsJax4bFdNWjxMwjrxKA8Wjz1lDsd3uM00s3FddCnskEtmDqRb18C92KWOBRnwXcO1ziUOZ0uTXKKZ2HXqUR6uHntLHUoXywSPeCkAXHYK1a3axpQDmdguH7bkycnHbg3Vr4kmMQ@Rj1eqHZAPh1VYGgRUCKcSClPHtV3dgD4Iegc6/XipU04/uspk9QNf9iqVHf3okhk0/WnIgquomdaz0PPOLs7Pfq@@/eN5d/A5iFUT888uSGDQMEFDc7P8exEo/Mwk49wZYzKS9clZJS@0nQZqN1CcPJkBtmm@mis2rrofs9q4@HK7eNgMx5V/fTm69L0jsj4098sNw7n@n/4A5/snE386mcHf9z5nY30zQU3dmjycVWO9BK2gqZ/xM/ouGOkP6CP21@UfY3Z2OTpnF@fjc7CYw1rf1At2s2a3q6ZZ3G5gLixcjaZDNTudV6O3t6vH5SaADYWndQWrB6O364fP95sgnMpZePpEtqfQfp63TjiZrx4/TtVgHk1m06VzTs/un82zGXzle3gbRKU@UdJJnoqQW4OOKoGmKV3wGOIq0sOpoEKFbHqC2hksdwZ55iZQ1OZSG/WMZHc0t6Mzry9abFjB3tqIWnZjRyY6RsbVXeDnH66P1@zkeO4fB9rny5AzHSVN9eIIKXXHb6pmqEPF3AKHyMbcX39aPX6es4@Loc8bnLz4vF4MW8eyqJKepwPk5yXDVbXeNBAu0Tryr/1BoN/3YUQkkc/8CH6DoH4vYArMrEObRXfB1d78YVrMemJLD8GxNW@qcbuLHyYa4@zlcZoDdecJVccrCQkDRyYhjbfaFPN5u8bzvw) with all results hardcoded in python, to check against.
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), ~~211~~ ~~204~~ ~~195~~ 192 bytes
```
(r,v,[,c,s,d,t]=r.match(/(.)(.T?)(X*)(.*)/),l=d.length,m=s>'D',g=(c*(m+=2)+!!s[1])<<l)=>10*(t<0?10*(l*(v?3*t+1:-"13"[~t]||3*t+4)||t):g+(10*l*-~v||m)*t+5*l+25*(c>5&&(5-c)*~-~v)+5*(g>9?4*v+6:1))
```
[Try it online!](https://tio.run/##jdA7b4MwFAXgvb@iYUjutQ3BPFKV8hiaOUsZkBADMo@0MlCBy4T469RZOlRV1Okene9M96Ocy0mM75/K7Ieq3ppog5HNLGeCTaxiqohGqyuVuMIRLAQrTRAyogPBIzIZVZas@1ZdWRdN8eF8YG0EXSKIS3e7KedFIIiDYSgxirlNQIV2cruSwJy4RFEemAZ3jXxVxbLcCg@XRWHQUtA7Scx1XpaOOqjJJ5I6PgER@/s9@KZAsmpHDdDGz4lHZnoKOOImhn4aZG3JoYUGDP5GbYM9NqWcasSXh1/sXlLK/@Fq/PqLT6/ZPfbO5h19uqRZZuoP/Cy2bw "JavaScript (Node.js) – Try It Online") Link includes test cases. Edit: Saved 6 bytes by multiplying by 10 at the end. Saved 9 bytes thanks to @Arnauld. Explanation:
```
(r,v
```
Input the result as a string and the vulnerability as a boolean (or 1/0).
```
,[,c,s,d,t]=r.match(/(.)(.T?)(X*)(.*)/)
```
Split the string up into contract, suit, doubles and (over/under)tricks.
```
,l=d.length
```
Count the number of doubles.
```
,m=s>'D'
```
Track whether this is a major or minor suit.
```
g=(c*(m+=2)+!!s[1])<<l
```
Calculate the contract score. This is 3 per major suit or 2 per minor suit trick, plus 1 extra for no trump, and then doubled or redoubled as appropriate.
```
)=>10*
```
The score is always a multiple of 10. Subsequent comments take this multiplication into account.
```
(t<0
```
Do we have undertricks?
```
?10*
```
Undertricks are multiples of 100.
```
(l*(v?3*t+1:-"13"[~t]||3*t+4)
```
If they're doubled, then the potentially redoubled score depending on the vulnerability or number of undertricks.
```
||t)
```
But if they're not doubled, then just the number of undertricks.
```
:g
```
If the contract is made, then we start with the contract score.
```
+(10*l*-~v||m)*t
```
Add on overtricks; per trick, if doubled then 100 potentially redoubled and doubled again if vulnerable, otherwise 30 for major or 20 for minor suits.
```
+5*l
```
Add on the potentially redoubled doubled game bonus.
```
+25*(c>5&&(5-c)*~-~v)
```
Add on the slam bonus if applicable.
```
+5*(g>9?4*v+6:1))
```
Add on the game bonus.
[Answer]
# [Python 2](https://docs.python.org/2/), ~~230~~ ~~225~~ ~~221~~ 220 bytes
I've posted this answer, as I found out the rules while creating this answer to the other question.
```
def f(D,V):v,s=D[:2];d=D.count('X');m=int(D.split()[1]);v=int(v);C=3-(s<'E');P=(v*C+(s=='N'))*2**d;W=-~V;return[-~W*25*max(0,v-5)+P+m*[C,10*W,20*W][d]+5*d+[5,30+20*V][P>9],((m-W)*3+7+~-V*max(0,m+3))*d*10or+W*m*5][m<0]*10
```
[Try it online!](https://tio.run/##dc9Na8IwGAfw@z5FYIe8S9LYdrPGS7urCJO2EHIYqzJhUWlr2S5@9S6oGzm4HB7Cnx/Py/G7/zjso3FsNluwRQUr8WxgnS7MLLJZo4vJ@@G07xGsIc6c3vlvMemOn7seYSMtzoZLNuAs14qjbg5fPFxpNJCcok5ruIQYk4iQJqs0P5dZu@lP7d7wc0WimLi3LyTYwGNMV9QRkzMpSMUiX6xpLI1JQ03MlKA@Kq1ZLZ4tQ8jxChNFU3rm5a2Ho8oPaogUh5ZWxJHYGjcX1gfjsfVL@vOgfAUCMiAwuL1HoBfgSTz8CbVcAyoDcxFTdY/IkCQhSfL6DpHpNDDTAvCQXA2XIjDpcl3XPlO/C11NKv5DMkCJR@MP "Python 2 – Try It Online")
---
Saved:
* -4 bytes, thanks to Mr. Xcoder
* -1 byte, thanks to Jonathan Frech
] |
[Question]
[
**This question already has answers here**:
[Balanced Ternary Converter](/questions/41752/balanced-ternary-converter)
(20 answers)
Closed 5 years ago.
A Math.SE user have a funny game explained as such:
>
> 1. Pick a random positive integer X.
> 2. Add +1, 0, -1 to make it divisible by 3Keep track of how much you've added and subtracted. That is your "score"..
> 3. Divide by 3 to create a new X.
> 4. Repeat steps 2 and 3 until you reach one.
>
>
>
I'm expecting the shortest code to give the correct score and the decomposition (as a list of the following values [+1;0;-1]) given an integer input.
```
Input => Expected score => Expected decomposition #explanation
12 => -1 => 0-1 #(12/3 => (4 - 1) / 3 = 1
^^^
25 => 0 => -1+10 (25 - 1) / 3 => (8 + 1) / 3 => (3 + 0) / 3 => 1
^^^ ^^^ ^^^
9320 => -1 => +1+1-10-1+1-1-1 #(9320 + 1) / 3 => (3107 + 1) / 3 => (1036 - 1) / 3 => (345 + 0) /3 => (115 - 1) / 3 => (38 + 1) / 3 => (13 - 1) / 3 => (4 - 1) / 3
^^^ ^^^ ^^^ ^^^ ^^^ ^^^ ^^^ ^^^
```
[Answer]
# JavaScript (ES6), 46 bytes
Returns an array where:
* the last term is the sum
* all preceding terms are the decomposition
```
f=(n,s=0)=>n-1?[k=1-++n%3,...f(n/3|0,s+k)]:[s]
```
[Try it online!](https://tio.run/##fY2xDoIwFEV3v@ItJm3oK31FBk2KH0IYCIJRSGuscfLfKwhilMTkDnc4J@dc3ktfXU@XG1p3qENoDLPCG8VNZpH2eWsIo8iuEyGlbJiNk4cSPmp5sct9ESpnvetq2bkjaxhpzgEgjiEHJQAJCkDM@rP6BnX6AZEE9FMTq37QbaJVD7/QkRwEJd4e0r8QaRpKcwgXxmZh6NkYC9MmIQ1P "JavaScript (Node.js) – Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), 53 bytes
Credit to Mr.Xcoder
```
f=lambda i,*s:i>1and f(-~i//3,*s,1--~i%3)or[s,sum(s)]
```
[Try it online!](https://tio.run/##K6gsycjPM/7/P802JzE3KSVRIVNHq9gq084wMS9FIU1Dty5TX98YKKRjqAtkqxpr5hdFF@sUl@ZqFGvG/i/PyMxJVTC0Uigoyswr0UjTAJGZeQWlJRqaQPDf0IjLyJTL0MgQiI24LI2NDAA "Python 3 – Try It Online")
# [Python 2](https://docs.python.org/2/), 55 bytes
```
f=lambda i,s=[]:i>1and f(-~i/3,s+[1--~i%3])or[s,sum(s)]
```
[Try it online!](https://tio.run/##FYZBCsMgEADvvsJLQakh3ZUeGkg/Ih4sqWQhMZI1lF76dWMHZpj8LfOWsNY4LmF9TUGS4dH5gZ4Q0iSj6n7UW8NXB13bi/V62x0bPlbF2tfPTMtbwiDzTqmoqP6llI@idKMCCrwLQGiieFi8nQ "Python 2 – Try It Online")
# [Python 2](https://docs.python.org/2/), 58 bytes
```
i,s=input(),[]
while~-i:s+=1--~i%3,;i=-~i/3
print s,sum(s)
```
[Try it online!](https://tio.run/##K6gsycjPM/qfnJ@SqmCroKSk9D9Tp9g2M6@gtERDUyc6lqs8IzMntU4306pY29ZQV7cuU9VYxzrTFsjQN@YqKMrMK1Eo1ikuzdUo1vwP1M6VWpGarAAyTsv0v6ERl5Epl6GRIRAbcVkaGxkAAA "Python 2 – Try It Online")
Returns list with decomposition and sum of it
] |
[Question]
[
**This question already has answers here**:
[Sum of all integers from 1 to n](/questions/133109/sum-of-all-integers-from-1-to-n)
(222 answers)
Closed 6 years ago.
The 52 week challenge is a way to save money. For example, Week 1, you save $1.00. Week 2 you save $2.00, and it continues through the year, adding one more dollar to each week’s savings goal. By Week 52, you’ll set aside $52.00, which will bring the year’s total savings to $1,378! Of course, you can decide how much money you start saving and how many weeks.
Given an amount for Week 1 and the number of weeks the challenge should run for, return the total amount saved at the end of the challenge.
Week 2 will have as twice the amount of Week 1, Week 3 will have thrice the amount of Week 1, etc.
### Examples
`1` and `52` weeks: `1378`
`5` and `6` weeks: `105`
`.25` and `100` weeks: `1262.5`
`10` and `1` week: `10`
`7` and `0` weeks: `0`
`0` and `30` weeks: `0`
`0` and `0` weeks: `0`
[Answer]
# Japt, 5 bytes
Takes weeks as the first input and starting amount as the second.
```
õ x*V
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.5&code=9SB4KlY=&input=NTIsMQ==)
[Answer]
# [J](http://jsoftware.com/), 6 bytes
```
*2!1+]
```
Takes the amount as the left argument and the weeks as the right argument.
[Try it online!](https://tio.run/##y/r/P81WT8tI0VA79n9qcka@gqFCmoKpEReYbQpkm0GYBnpGIJ6hgQGEb2gA4kHY5kAmVBgkaozENvgPAA "J – Try It Online")
### Explanation
```
* 2 ! 1 + ]
1 + ] Add 1 to the weeks.
2 ! (Weeks + 1 choose 2)
* Multiply by the starting amount.
```
This takes advantage of the fact that the nth triangle number is (n+1 choose 2). Perhaps unsurprisingly, [this is almost the exact same answer as the one I have for the sum of digits from 1 to n challenge](https://codegolf.stackexchange.com/a/133168/42833). Just substitute `>:` for `1+]` and tack on the `*`.
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 13 bytes
```
#*(#+1)*#2/2&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n2b7X1lLQ1nbUFNL2UjfSO1/QFFmXomCg0JatKmRjmHsfwA "Wolfram Language (Mathematica) – Try It Online")
[Answer]
# [R](https://www.r-project.org/), 23 bytes
```
function(a,w)sum(0:w*a)
```
[Try it online!](https://tio.run/##K/qfpmCj@z@tNC@5JDM/TyNRp1yzuDRXw8CqXCtR83@ahqmOmeZ/AA "R – Try It Online")
Takes input as `a`mount, `w`eeks.
[Answer]
# [Python 3](https://docs.python.org/3/), 20 bytes
```
lambda a,w:a*w*-~w/2
```
[Try it online!](https://tio.run/##K6gsycjPM/6fZhvzPycxNyklUSFRp9wqUatcS7euXN/of1p@EVBEIUkhM09Bw1DH1EhTR8NUxwxI6hmZ6hgaGABZhgY6hkDKXAfEMdAxhlAGmlZcCgoFRZl5JRppGok6SZqa/wE "Python 3 – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 3 bytes
```
R×S
```
[Try it online!](https://tio.run/##y0rNyan8/z/o8PTg////m/03BQA "Jelly – Try It Online")
] |
[Question]
[
[<< Prev](https://codegolf.stackexchange.com/questions/150028/advent-challenge-6-transport-dock-relabeling) [Next >>](https://codegolf.stackexchange.com/questions/150355/advent-challenge-8-storage-cart-transport-planning)
After some careful analysis, Santa was able to determine the dock size ranges and get the presents into the correct transportation dock.
Now, he needs you to help him balance out the transportation carts and place the presents in them in the most balanced fashion.
# Challenge
You will be given the size of (the base of) the transportation cart as `(width, height)` and a list of all of the presents' sizes as integers.
An arrangement of presents on the transportation cart will have a certain center of mass, which should be as close to the center as possible (in other words, you want to minimize the Euclidean Distance between the center of mass and `(width / 2, height / 2)`. The center of mass can be calculated by the following formula.
# Formula
Let `{(x_1, y_1), (x_2, y_2), ..., (x_i, y_i)}` be the coordinates of the centers of the presents (these coordinates may be half-numbers (so #.5) if the
size is even). Let `s = {s_1, s_2, ..., s_i}` be the sizes of the presents.
Then, the center of mass is at `((x_1 × s_1 + x_2 × s_2 + ... + x_i × s_i) / sum(s), (y_1 × s_1 + y_2 × s_2 + ... + y_i × s_i) / sum(s))`.
# Task
Given the dimensions of the transportation cart `m × n` and the sizes of the presents, determine the positions of the presents in the most balanced arrangement. Note that presents may not intersect; each present with size `s` is an `s × s × s` cube.
# Formatting Specifications
You may give the output in any reasonable format; for example, the positions of the top-left corners of the presents, the centers, an `m × n` matrix of integers indicating what present covers each space, etc. If there are multiple valid answers, you may return just one (does not have to be deterministic) or you can return them all.
# Test Cases
```
Input
Output (given as the `m × n` matrix as ASCII-art)
----
5 × 5, 2, 2, 2, 2
11022 00220
11022 11220
00000 or 11033
33044 04433
33044 04400
----
5 × 7, 1, 1, 1, 2, 2
1000022
0000022
0003000 (or others)
4400000
4400005
----
3 × 4, 3
1110
1110
1110
---
3 × 4, 2, 1
0110
0110
0020
```
Please feel free to correct me if my test cases are not correct.
# Rules
* Standard Loopholes Apply
* This is a [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest answer in bytes wins
* No answer will be accepted
* There will always be at least one solution to all of the inputs
Note: I drew inspiration for this challenge series from [Advent Of Code](http://adventofcode.com/). I have no affiliation with this site
You can see a list of all challenges in the series by looking at the 'Linked' section of the first challenge [here](https://codegolf.stackexchange.com/questions/149660/advent-challenge-1-help-santa-unlock-his-present-vault).
Happy Golfing!
[Answer]
# [Python 3](https://docs.python.org/3/), ~~533~~ ~~494~~ 476 bytes
```
from numpy import*
def o(a,v,t=[],n=1):
if len(v)<1:return[[sum((d-e)**2for d,e in zip([sum(a)/sum(r)for a in zip(*[[a*k for k in b]for a,b in zip(r,t)])],[-~a/2 for a in a.shape]))**.5,a]]
s,k=v[0],[[]]
for p,i,j,l in[[copy(a),i,j,(i-~s/2,j-~s/2)]for i in range(a.shape[0]-s+1)for j in range(a.shape[1]-s+1)if all(a[i:i+s,j:j+s]<1)]:p[i:i+s,j:j+s]=n;k+=o(p,v[1:],t+[l],n+1)
return k
w=input()
q,r=w[0],w[1:]
print(min([a for a in o(zeros(q),r)if a],key=lambda a:a[0])[1])
```
[Try it online!](https://tio.run/##ZVHLbsMgELz7K/YI9iapXeXihi9BHEiNG/wAgh1HziG/7oLTpKoqIa2YWWaHWTePJ2veF23cZQQGneyPlSyB8z3CXiAUryOW2tsezKV3M@jeWT@mSaVqsETihCPjAg3LaZmArqFThkz0kJdejRdvOB8uPSHVRtE0LWrroUIF2sBNO7Jyku5i8TSS8kmlnMu0hYi1ETuKlcbjs8HjSAUVyDd3uSvg9Vhuh5N0StAwb7tHKUQCA7Zs4m@hmcdr7HWoscEuvOD807o52FgRojf3YVdgsxa6TtVR10vzpciPetDaDFm@Wm7@s/mDDWnIriOS61JnAzZlkw3ikFNRuj8QMx9txixxOPG8FDhmvAuRBoUEHilCm1zZuipCkzN6do2/ucbuxHltRtJrQ7j8jcGSm/J2IGeKfjUisFUze6wZZCmDAA1G6bJ8Aw "Python 3 – Try It Online")
I used the `numpy` library in Python. It is a very popular Python library and it specializes matrix/multi-dimensional array manipulation.
Mine finds a different, but equally valid, solution. I did double check my work and, when I tried to find all solutions, it did find the one presented in the question as well.
Basic methodology is to bruteforce it. So, every possible present location is checked, then the one with the least distance between it's center of gravity and the center of the slay is returned (or at least one of the possible solutions).
---
# Pseudo-Ungolfed Version
I figured providing the ungolfed version would help people understand the algorithm. I have made marginal improvements since this version, but this should give you a jump start in understanding it:
```
import numpy as np
with open("test.txt","w") as fo:
input = lambda: [[3,4], 2, 1]
def bruteForce(array, size, number):
for i in range(array.shape[0]-size+1):
for j in range(array.shape[1]-size+1):
if np.all(array[i:i+size,j:j+size] == 0):
temp = np.copy(array)
temp[i:i+size,j:j+size] = number
yield temp, (i+(size+1)/2,j+(size+1)/2)
#y, x because of how numpy works
#euclid = https://codegolf.stackexchange.com/a/70536/67929
def recursiveCheck(array,presents,presentLocations=[],number=1,currentMin=[10000,[]]):
global rest, size
if (len(presents) == 0):
centerI = sum(a*b[0] for a,b in zip(rest,presentLocations)) / sum(rest)
centerJ = sum(a*b[1] for a,b in zip(rest,presentLocations)) / sum(rest)
euclid = lambda a,b:sum((d-e)**2for d,e in zip(a,b))**.5
centerDelta = euclid([centerI,centerJ],[(a+1)/2 for a in array.shape])
if centerDelta <= currentMin[0]:
currentMin[0] = centerDelta
currentMin[1] = array
fo.write(repr(array) + "\n")
fo.write(repr(presentLocations) + "\n")
fo.write(repr([centerI,centerJ]) + "\n")
fo.write(repr(centerDelta) + "\n")
return
for potentialPresentArray, newPresentLocation in bruteForce(array,presents[0],number):
recursiveCheck(potentialPresentArray,presents[1:],presentLocations+[newPresentLocation],number+1,currentMin)
suMatrix = input()
size = suMatrix[0]
rest = suMatrix[1:]
recursiveCheck(np.zeros(size),rest)
```
---
# Credits
I used [a response](https://codegolf.stackexchange.com/a/70536/67929) by [CarpetPython](https://codegolf.stackexchange.com/users/31785/carpetpython) to aide me in creating a euclidean distance calculation in a minimal amount of bytes.
[Mr. Xcoder](https://codegolf.stackexchange.com/users/59487/mr-xcoder) reduced it by 28 bytes.
] |
[Question]
[
**This question already has answers here**:
[Give me the Gray Code list of bit width n](/questions/32871/give-me-the-gray-code-list-of-bit-width-n)
(16 answers)
Closed 7 years ago.
[Gray Code](https://en.wikipedia.org/wiki/Gray_code) is a number system where only 1 bit of the number changes from one number to the next number. Print the 8 bit Gray Code values of 0 to 255.
Shortest Code wins!
Start of output:
```
0 00000000
1 00000001
2 00000011
3 00000010
4 00000110
5 00000111
6 00000101
7 00000100
...
```
You only have to print the Gray Code in binary. The decimal numbers in the example are just for reference.
[Answer]
# [Ruby](https://www.ruby-lang.org/en/), 48 33 Bytes
15 Bytes saved thanks to [G B](https://codegolf.stackexchange.com/users/18535/g-b)
```
256.times{|i|puts "%08b"%(i^i/2)}
```
[Answer]
# C, 89 bytes
(Note: Leading Zeros Omitted from output)
```
q;main(a){a--;for(q=a^(a>>1);q;)printf("%c%i",8207,q%2),q/=2;puts("");a<256?main(a+2):0;}
```
---
I use a very neat trick in this one:
>
> It converts a decimal to gray code (base 10), then convert that to binary which will print the grey number in *reverse order*. But before each time I output the mirrored grey number, I print U+200F or char(8207) which is a [Right-To-Left marker character](https://en.wikipedia.org/wiki/Right-to-left_mark) which causes output to be mirrored (and on the right side of my screen). Mirroring my backwards grey number outputs, thus making them forward, proper grey numbers (At least to human eyes, to the computer they are still backwards).
>
>
>
Notice the numbers are different in the LTR output, they are mirrored grey numbers.
[](https://i.stack.imgur.com/tlJym.png)
(Note: Leading Zeros Omitted from output)
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 10 bytes
```
⁹ḶH+^ḶBḊ€Y
```
[Try it online!](https://tio.run/nexus/jelly#@/@ocefDHds8tOOApNPDHV2PmtZE/v8PAA "Jelly – TIO Nexus")
[Answer]
# PHP, ~~43~~ 40 bytes
unpadded
```
for(;$i<256;$i++)printf("%b\n",$i^$i/2);
```
+2 bytes for padded: replace `%b` with `%08b`.
Thanks @user63956 for reminding me of printf.
[Answer]
# Python, 53 bytes
`for i in range(256): print(bin(i^(i>1))[2:].zfill(8))`
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/108324/edit).
Closed 7 years ago.
[Improve this question](/posts/108324/edit)
Inspired by [Sygmei's question](https://codegolf.stackexchange.com/questions/108229/your-very-own-for-instruction), I'm interested in finding out what languages can "do this properly".
Your task is to write a "for loop" function / macro / instruction. The arguments should be:
* an initializer
* a test
* an increment
* a body
All of these are "pieces of code" and should be able to access variables in the context of the call. The body should be able to include multiple statements.
The aim is to have the fewest lexical tokens excluding comments, except that `#define` and friends (using a dumb preprocessor) are worth 50, and `eval` and friends (taking a string argument) are worth 100. Feel free to make your code readable with comments, whitespace and meaningful names.
You should include a "test harness" which is not counted towards length.
The C version definitely won't win:
```
// the do {...} while (0) idiom enables a code block to be a single C statement, so it can safely be followed by a semicolon
#define my_for(init, test, inc, body) do { \
init; \
while (test) { \
body; \
inc; \
} \
} while (0)
// test harness:
#include <stdio.h>
main()
{
int i, total;
my_for((i=1, total=0), i<=3, ++i, {printf("%d\n", i); total=total+i;});
printf("total: %d\n", total);
}
```
Edit to add: the meaning of "[lexical token](https://en.wikipedia.org/wiki/Lexical_analysis#Token)" depends on your language. Here's how the scoring breaks down for my C version:
`//`[...]: 0
`#define`: 1 occurrence, 50 points
`my_for`: 1
`(`: 3
`init`: 2
`,`: 3
`test`: 2
`inc`: 2
`body`: 2
`)`: 3
`do`: 1
`{`: 2
`\`: 6
`;`: 3
`while`: 2
`}`: 2
`0`: 1
*TOTAL*: 85
[Answer]
## Python, ~~11~~ 26 tokens:
```
def f(n, t, i, l):
n()
while t():
l()
i()
```
This is my first time doing [atomic-code-golf](/questions/tagged/atomic-code-golf "show questions tagged 'atomic-code-golf'"), so forgive me if I got the token counting wrong.
**EDIT**: Hugh Allen informed me that I got the token counting wrong.
[Answer]
# [Perl 6](http://perl6.org/), 24 tokens
```
sub my-for (&init, &test, &inc, &body) {
init;
while (test) { body; inc }
}
```
Tokens:
```
while 1 keyword
sub 1 keyword
my-for 1 function name (declaration)
&init 1 function parameter (declaration)
&test 1 function parameter (declaration)
&inc 1 function parameter (declaration)
&body 1 function parameter (declaration)
init 1 function name (implicit call)
test 1 function name (implicit call)
inc 1 function name (implicit call)
body 1 function name (implicit call)
, 3 parameter list separator
; 2 statement separator
{ 2 block opener
} 2 block closer
( 2 parameter list opener
) 2 parameter list closer
```
Test:
```
my ($i, $total);
my-for {$i=1; $total=0}, {$i <= 3}, {++$i}, {
say $i;
$total = $total + $i;
}
say "total: $total";
```
[Answer]
# tcl, could I say 0 due to point 1.?
If the question was "how many ways your language allow you to do it", tcl would certainly score a good amount.
1. for
The language's normal `for` works this way; it should me noted that tcl has no keywords, so `for` works exactly like a function *(side note: its behaviour can even be redefined!)*. Then, there is no need to implement it:
```
for {set i 0;set total 1} {$i<=3} {incr i} {puts $i; incr total $i}
puts total:\ $total
```
2. proc
Implement a function, strictly according to the question.
2.1. uplevel
The `uplevel 1` will execute its contents 1 level up in the call stack, to allow there the access to the variables of the `for` input; otherwise we could not access `$total`, because it would be not defined.
```
proc F {s t i b} {uplevel 1 [list for $s $t $i $b]}
F {set i 0;set total 1} {$i<=3} {incr i} {puts $i; incr total $i}
puts total:\ $total
```
2.2. tailcall
From `tailcall` documentation: "The tailcall command replaces the currently executing procedure, lambda application, or method with another command."
```
proc P args {tailcall for {*}$args}
P {set i 0;set total 1} {$i<=3} {incr i} {puts $i; incr total $i}
puts total:\ $total
```
3. interp alias
You can say to one of the interpreters currently existing on interpreters tree that a command has an alias. I didn't create any interpreter, so I am interested on the tree's root interpreter, which path is an empty string, represented by `{}`. The following line means: "Create the alias `R` on the *root* interpreter, which will re-route calls to it to `for` on the *root* interpreter.
```
interp alias {} R {} for
R {set i 0;set total 1} {$i<=3} {incr i} {puts $i; incr total $i}
puts total:\ $total
```
4. set
You can define a var that will have the same value has `for` command:
```
set S for
$S {set i 0;set total 1} {$i<=3} {incr i} {puts $i; incr total $i}
puts total:\ $total
```
5. rename
You can change the name of the function. Note: From now on, you can not call `for` directly again! Now you must always call `f`, until you rename it back!
```
rename for f
f {set i 0;set total 1} {$i<=3} {incr i} {puts $i; incr total $i}
puts total:\ $total
```
[demo](http://rextester.com/OCMP58135)
] |
[Question]
[
**This question already has answers here**:
[Binary to decimal converter](/questions/102219/binary-to-decimal-converter)
(84 answers)
Closed 7 years ago.
# The problem
Given a binary number from 0 to 111111 convert it to trinary. (Base 3). Then print the result.
## Rules
No using a list of conversions.
Don't cheat
You must use a string as the number
No compressing the input string As I will be testing the code with several different numbers I can't use compressed strings
## Notes
By trinary I mean counting in base 3. So 0,1,2,10,11,12,20... ect
Leading zeros will be present 001101
Most important number is on the left.
## Example
```
String input = "110111"
String a = code(input);
print(a);
```
# To win
This is code golf!
Do it correctly and in the smallest size.
[Answer]
# Bash 25 bytes
**Golfed**
```
bc<<<"ibase=2;obase=3;$1"
```
[Answer]
## JavaScript (ES6), 26 bytes
```
s=>(+`0b${s}`).toString(3)
```
[Answer]
# Ruby, ~~97~~ 87 bytes
```
f=->a{x=0
a.chars.map{|i|x+=x+i.ord%2}
o=x>0?"":?0
(o=(48+x%3).chr+o
x/=3)while x>0
o}
```
Old version:
```
def f a
x=0
a.chars.map{|i|x=x+x+i.ord%2}
o=x>0?"":"0"
while x>0
o=(48+x%3).chr+o
x/=3
end
o
end
```
] |
[Question]
[
Based on [my SO question](https://stackoverflow.com/q/37302530/321973), but more specifically:
Find a RegEx such that, given a text where paragraphs end with an empty line (or `$` at the very end), match the up to twenty last characters of a paragraph excluding the `\r` or `$` but no more than three *complete* "words" including the "separators" in between and the punctuation following it. The following constraints apply:
* "words" also include abbreviations and the like (and thus punctuation), i.e. "i.e." and "non-trivial" count as one word each
* whitespaces are "separators"
* isolated dashes do not count as "words" but as "separators"
* "separators" *before* the first word must not be included
* trailing punctuation counts to that limit, but not the leading one nor the linebreaks and `$` that must not be in the matching group
* whether trailing punctuation is included in the match or not is up to you
Some examples:
>
> The early bird catches the **worm. Two words.**
>
>
> But only if they got **up - in time.**
>
>
> Here we have a supercalifragilisticexpialidocious **etc. sentence.**
>
>
> **Short words.**
>
>
> Try accessing the **.html now, please.**
>
>
> Vielen Dank **und viele Grüße.**
>
>
> Did **any-one try this?**
>
>
>
Score is given in bytesteps: bytes multiplied by amount of steps according to <https://regex101.com>, but there are three penalties:
* if the upper limit of words cannot *trivially*+ be modified: +10%
* if the upper limit of character count cannot *trivially*+ be modified: +10%
* failure to handle unicode used in actual words: add the percentage of world population speaking the language according to [Wikipedia](https://en.wikipedia.org/w/index.php?title=List_of_languages_by_number_of_native_speakers&oldid=718585003#Nationalencyklopedin) the failing word stems from. Example: Failing to match the German word "Grüße" as a word => +1.39%. Whether you consider a language's letters as single characters or count the bytes to utf8-encode them is up to you. The penalty does not have to be applied before someone actually provides a counter-example, so feel free to demote your competitors ;)
Since this is my first challenge, please suggest any clarifications. I assume [regular-expression](/questions/tagged/regular-expression "show questions tagged 'regular-expression'") means there are no "loopholes" to exclude.
---
+ With *trivially* modified I mean expressions such as `{0,2}` and `{21}` are valid but repeating something three times (which would have to be re-repeated to increase the amount words) is not.
[Answer]
# ~~37 bytes \* 1403 steps = 51911 bytesteps~~
# ~~34 bytes \* 1036 steps = 35224 bytesteps~~
# 37 bytes \* 666 steps = 24642 bytesteps
```
(?<!\S)(?!.{21})\S+(( | - )\S+){0,2}$
```
[Verify it here!](https://regex101.com/r/bR7bB7/6)
] |
[Question]
[
**This question already has answers here**:
[Minimum perimeter of an area [duplicate]](/questions/18349/minimum-perimeter-of-an-area)
(11 answers)
Closed 8 years ago.
### Introduction
The task is simple. When given a number, output the most logical rectangle. To explain what a logical rectangle is, I provided some examples:
Input: `24`.
All possible rectangles have the form `A x B`, (`A` and `B` are both positive integers). So, all possible rectangles for `24` are:
* `1 x 24`
* `2 x 12`
* `4 x 6`
From this list, the most logical rectangle has the lowest `A + B`:
* `1 + 24 = 25`
* `2 + 12 = 14`
* `4 + 6 = 10`
You can see that `4 x 6` is the most logical rectangle, so we will output `4 x 6` (or `6 x 4`).
### The rules
* Given an integer from `1` to `99999`, output the most logical rectangle.
* You may write a function or a program.
* The spaces in the output are not required.
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the submission with the least amount of bytes wins!
### Test cases
```
Input > Output
1 > 1 x 1
4 > 2 x 2
8 > 4 x 2 (or 2 x 4)
15 > 5 x 3 (or 3 x 5)
47 > 1 x 47 (or 47 x 1)
5040 > 72 x 70 (or 70 x 72)
40320 > 210 x 192 (or 192 x 210)
```
[Answer]
## CJam, 26 bytes
```
ri_mQ),W%{1$\%!}=:X/" x "X
```
or
```
ri_mQ{)1$\%!},W=):X/" x "X
```
[Test it here.](http://cjam.aditsu.net/#code=ri_mQ)%2CW%25%7B1%24%5C%25!%7D%3D%3AX%2F%22%20x%20%22X&input=24)
Finds the largest divisor less than or equal to the square root of the input as one of the two side lengths.
[Answer]
# Pyth, 18 bytes
```
jd[Kf!%QTs@Q2\x/QK
```
Try it online: [Demonstration](http://pyth.herokuapp.com/?input=24&code=jd%5BKf%21%25QTs%40Q2%5Cx/QK&test_suite_input=1%0A4%0A8%0A15%0A47%0A5040%0A40320&test_suite=0) or [Test Suite](http://pyth.herokuapp.com/?input=24&code=jd%5BKf%21%25QTs%40Q2%5Cx/QK&test_suite_input=1%0A4%0A8%0A15%0A47%0A5040%0A40320&test_suite=1)
Same idea as Martin's. Finds the first number >= floor(sqrt(n)), that divides n.
### Explanation:
```
jd[Kf!%QTs@Q2\x/QK implicit: Q = input number
@Q2 sqrt(Q)
s floor, converts ^ to an integer
f find the first number T >= floor(sqrt(Q)), that satisfies:
!%QT Q mod T == 0
K store this number in K
[K \x/QK create the list [K, "x", Q/K]
jd join by spaces
```
[Answer]
## Java 8, 86 bytes
```
n->{for(int i=(int)Math.sqrt(n);;i--)if(n%i==0){System.out.print(i+"x"+n/i);return;}};
```
Lambda function, test with:
```
public class Rectangle {
interface Test {
void run(int v);
}
public static void main (String[] args){
Test test = n->{for(int i=(int)Math.sqrt(n);;i--)if(n%i==0){System.out.print(i+"x"+n/i);return;}};
int[] testCases = {1, 4, 8, 15, 47, 5040, 40320};
for (int i : testCases) {
test.run(i);
System.out.println();
}
}
}
```
Finds the largest divisor less than or equal to the square root of the input. Same concept as the CJam and Pyth answers.
] |
[Question]
[
These days, I watched on TV a Gay Pride parade; at the time, I was thinking about quines and how they're a bit queer, outputting themselves (out of the closet?) and, well, why not combine both things into a Quine Pride Parade?
The challenge is to write a program that:
1. Is a quine.
2. Prints the sentence `I am a quine written in <language name>, and very proud of it!` with the name of the language you're using in place of `language name`.
3. Contains the sentence within a rectangular frame of non-whitespace characters, with at least one row/column of spaces above, below, before and after it.
4. Contains the sentence in three rows, with centered text, like in my entry below. You can add at most one space before the language name, to align the second line within the frame.
The program itself does not need to have a rectangular form, but must frame the sentence.
**Scoring**
As Dennis pointed out, languages with shorter names have an advantage, and most bytes will go into the frame.
So, the scoring will be as follows: size of the program (in bytes), minus the size of the language's name, minus 140 (a tweet's size). The following bonuses are applied after that:
* -50% if the program also accepts a custom sentence, outputs it on the generated program's frame instead of the default message, and the generated program is still a quine. Assume a tweet-sized sentence (140 chars max). Without input, it can output, either the default sentence above, or an empty frame.
* -30% if the program shows only one copy of the sentence (the other should be obfuscated).
The bonuses stack: getting both does (n - 50%) - 30% = 0.5n - 30% = 0.35n.
The smallest score wins.
Here is my entry, in Ruby - should have a linebreak at the end. No bonus, score 399 = 543 bytes - 4 - 140.
```
q=34.chr;e=10.chr;prideful=''+
' '+e+
' I am a quine '+e+
' written in Ruby, '+e+
' and very proud of it! '+e+
' '+e;s=[
"q=34.chr;e=10.chr;prideful=''+",
"' '+e+",
"' I am a quine '+e+",
"' written in Ruby, '+e+",
"' and very proud of it! '+e+",
"' '+e;s=[",
"@",
"];t=s.map{|x|q+x+q}.join(','+e)",
"s.each{|y|puts(y!='@'?y:t)}"
];t=s.map{|x|q+x+q}.join(','+e)
s.each{|y|puts(y!='@'?y:t)}
```
It is a classic quine format: `s` contains itself, as an array (one element per line), except for itself's quote (the `@`); then, joins `s`, substituting `@` by the join, quoted.
The program can clearly be golfed further: I went for a nice rectangular format instead.
[Answer]
## [Aubergine](https://esolangs.org/wiki/Aubergine), 7\*24+1-9=160-140=20-30%=14 bytes
```
-a1+a1=oA=Bi-BA:bB=iaooo
o o
o I am a quine written o
o in Aubergine, and o
o very proud of it! o
o o
oooooooooooooooooooooooo (removethis)
```
The (removethis) is not code, but is just there to protect the trailing whitespace.
It's just my standard aubergine quine with all the extra stuff stuck in it to meet requirements.
] |
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
Closed 9 years ago.
* **General programming questions** are off-topic here, but can be asked on [Stack Overflow](http://stackoverflow.com/about).
* Questions without an **objective primary winning criterion** are off-topic, as they make it impossible to indisputably decide which entry should win.
[Improve this question](/posts/27074/edit)
You need to implement immutable dictionaries using only functions without any other data types (custom or built-in).
The dictionary must be indexed by any data type of class Eq and contain values of arbitrary type, but all the values in a dictionary should be of the same type.
Here are some examples of usage:
```
dict `access` True -- returns value of key True
dict `access` "y" -- returns value of key "y"
(update "x" 10 dict) `access` "x" -- returns 10 for any dict
```
[Answer]
```
update key1 value obj = \key2 -> if key2 == key1 then value else obj key2
access = id
```
Given the above definitions, your examples should work. Also, you can define an empty dictionary as `const x` where `x` is the default value for keys not in the dictionary.
] |
[Question]
[
**This question already has answers here**:
[Ascending matrix](/questions/8543/ascending-matrix)
(10 answers)
Closed 9 years ago.
There is a table (the matrix one, not the one in your kitchen) called the "mex table". It has a left-top cell, at coordinates (0,0), but extends to infinity rightwards and downwards. The x-coordinate increases to the right and the y-coordinate increases downwards.
Every cell has a value >=0, and the cell at (0,0) has the value 0. The value of any other cell is defined as the **lowest integer, >=0**, which does not occur directly above it or directly to the left of it.
The start of the mex table looks like this:
```
+---+---+---+---+---+-
| 0 | 1 | 2 | 3 | 4 | ..
+---+---+---+---+---+-
| 1 | 0 | 3 | 2 | 5 | ..
+---+---+---+---+---+-
| 2 | 3 | 0 | 1 | ..
+---+---+---+---+-
| 3 | 2 | 1 | ..
+---+---+---+-
| 4 | 5 | ..
+---+---+-
| : | : | \
```
So, for example, the cell at (2,1) is 3 because 0 occurs left of it, 1 occurs left of it and 2 occurs above the cell. The cell at (3,1) is 2, however, because in the part of the row directly to the left of (3,1) and the part of the column directly above (3,1), 0, 1 and 3 occur, but 2 doesn't.
*Objective:* Print, to standard output, the number in the cell at (x,y) given two integers, both >=0, on standard input, space-separated and newline-terminated.
*Thunderbirds are GO!*
(This is derived from a question from the national finals of the Dutch Informatics Olympiad of some time ago.)
[Answer]
## GolfScript (2 chars)
```
~^
```
This is familiar to anyone who knows anything at all about combinatorial game theory.
[Answer]
## J, 7 characters
```
#.~:/#:
```
Usage:
```
#.~:/#:3 5
6
#.~:/#:2 3
1
```
] |
[Question]
[
The Holy Grail Layout in CSS, is a full height, 3 column layout which consists of a fluid central column, and two side columns with fixed widths.
## Your Task is Simple!
Reverse it, make a fixed width central column, and two fluid width columns to the sides. The point is for them to take **All available space *both vertically and horizontally***. So if one adds elements above, or elements below (assume 100% width), your solution should shrink to accommodate. Same goes with elements on the sides. Your layout should fill 100% of its container's space.
## Restrictions
* HTML and CSS only (no JavaScript)
* IE8+ support mandatory
* Must work in all major browsers (it is, after all, a layout!)
* HTML and CSS must both be **valid**.
* No tables, it's supposed to be a layout, not an abomination.
## Winner
* Code with fewest characters wins, **excess spaces and newlines do not count, don't be afraid to be readable!** (I'm running the solution through a minifier)
---
Good luck!
[Answer]
Simple
```
<div style=float:left;>L</div><div style=float:right;>R</div><div style="width: 100px;margin:0px auto;">C</div>
```
* Who said that it needs to be valid html?
* Who said that I need a doctype?
[Answer]
display:table-cell is compatible ie8+ (as seen in caniuse)
```
<!DOCTYPE html>
<head>
<title>a</title>
<style>
html { height: 100%}
body { margin: 0; display: table; height: 100%; width: 100%}
.c { display: table-cell }
.c2 { width: 6em }
</style>
</head>
<a class="c c1">a</a>
<a class="c c2">z</a>
<a class="c c3">e</a>
```
This is html/css valid, tried here : <https://validator.w3.org/nu/#textarea>
That's why there is head/title stuff.
But you can ommit html/body, according to the specs.
The issue I see is when you want to put something above/below, you have to make them `display: table-row`, and probably specify a `height`.
[Answer]
Guaranteed to work in all browsers - old and new:
```
<table>
<tr>
<td>a</td>
<td class="f">b</td>
<td>c</td>
</tr>
</table>
```
CSS:
```
table, tr{
width: 100%;
}
.f{
width:100px;
}
```
Here's a fiddle: <http://jsfiddle.net/8QWBX/1/>
Note: if you want to make it shorter (but fail HTML standards) you may remove the `tr` tag and its styling. This will save 12 characters the way I see it.
] |
[Question]
[
the question is "complete this subtraction by replacing the asterisks with digits so the numbers 1-9 only appear once each"
```
9**
-*4*
____
**1
```
my code tries random numbers until it works, and displays the answer. here is the entire html app. I want one to fit in a tweet at 140 characters (not counting tags)
```
<script>
function r(){return Math.random()*9+1^0}
do{a=900+r()*10+r(),b=r()*100+40+r(),c=a-b,s=''+a+b+c
}while(c%10!=1||eval('for(i=0;i++<9;)if(s.indexOf(i)<0)1'))alert(s)
</script>
```
Is there any way to make this shorter, including with a different solution?
SOLVED!:
Thanks Peter, Shmiddty and copy, currently I have 91 chars!
```
for(x=1;++x<999;)for(y=1;y<x;)/(?!.*0|.*(.).*\1)9...4...1/.test(s=''+x+y+(x-y++))&&alert(s)
```
[Answer]
## JavaScript (118 110 102 96 95 99 98 93 chars)
```
for(x=1;x;x++)for(y=1;y<x;)/(?!.*0|.*(.).*\1)9...4...1/.test(s=''+x+y+(x-y++))&&alert(s,x=-1)
```
This will give the lexicographically smallest solution. Thanks to [copy](https://codegolf.stackexchange.com/users/3428/copy) for 98->93.
You can enumerate all of them for 91 chars:
```
for(x=1;++x<999;)for(y=1;y<x;)/(?!.*0|.*(.).*\1)9...4...1/.test(s=''+x+y+(x-y++))&&alert(s)
```
Thanks to [Shmiddty](https://codegolf.stackexchange.com/users/7192/shmiddty) for pointing out a standard optimisation which slipped straight past me.
Allowing `0` as well, in <2.5 tweets, here's the analysis:
```
9ab-c4d=ef1; b-d in {1,-9}; 2nd => d=9 so bd in {32,65,76,87}, no carry. a-f in {4,*-6} so af in {62,73,*06,*28}. 9-c=e or *8-c=e so ce in
{27,36,63,72} or *{08,26,35,53,62,80}. af in {62,73} => no ce. af in {06,28} => ce in {35,53}; 06 => bd=87; 28 => bd=76. So four solutions:
927-346=581; 927-546=381; 908-347=561; 908-547=361
```
Removing `0` shrinks the analysis to fit in two tweets:
```
9ab-c4d=ef1; b-d in {1,-9}; 2nd => d=9 so bd in {32,65,76,87}, no carry. a-f in {4,*-6} so af in {62,73,*28}. 9-c=e or *8-c=e so ce in
{27,36,63,72} or *{26,35,53,62}. af in {62,73} => no ce. af=28 => ce in {35,53} => bd=76. So 927-346=581; 927-546=381.
```
[Answer]
# k (116 chars)
It's possible in k... Returns all possible solutions. (Count ignores unnecessary whitespace).
```
{a:"9",','[;"1"]i@&:6=#:'i:?:'{,/x,/:\:y}/7#,:"8765320";
b:"I"$0N 3#/:a[;i],'"4",'a[;4+i:!4];
b@&:b[;2]='(-).'b[;0 1]}
```
] |
[Question]
[
**This question already has answers here**:
[Tips for golfing in Visual Basic .NET](/questions/155840/tips-for-golfing-in-visual-basic-net)
(3 answers)
Closed 2 years ago.
Any general tips for golfing in VB.net?
This, similar to Pascal, is a very rarely used language, thus having very few resources online
Visual Basic.NET (VB.NET) is a multi-paradigm, managed, type-safe, object-oriented computer programming language. Along with C# and F#, it is one of the main languages targeting the .NET Framework. VB.NET can be viewed as an evolution of Microsoft's Visual Basic 6 (VB6) but implemented on the Microsoft.NET Framework.
(Quoted from <https://stackoverflow.com/questions/tagged/vb.net>)
Please post each tip as a separate answer
[Answer]
If there is no parameters, you can remove the '()' when you call a function.
```
Console.ReadLine().Split()
Console.ReadLine.Split
```
[Answer]
You don't have to test booleans, you can test integers, it's true if not 0.
```
if(a<>0,do this,do that)
if(a,do this, do that)
```
] |
[Question]
[
The player has to keep guessing a number from 1 to 10 until they guess the correct number to win the game. If they make an incorrect guess, they're told if their guess was too low or too high.
Each line has to render below the previous line for me to accept the solution as the new code for the game (However, you can still share any solutions that break that rule.). For example, no lines can be rendered over other lines, such as "CORRECT." over "TOO LOW." or "TOO HIGH.".
Here's the code:
```
0N=RND(10)+1:DIMT$(2):T$(0)="CORRECT.":T$(1)="TOO LOW.":T$(2)="TOO HIGH.":F.T=0TO0:I."WHAT'S MY NUMBER? (1-10) ",G:T=G<>N:?T$(-(G>N)-T):N.
```
As for how I'm running NS-HUBASIC code, I'm doing it in Family BASIC V3.0, which I'm running under Nestopia v1.40.
If you need any documentation, you can find it here: <https://gamefaqs.gamespot.com/nes/938747-family-basic-v3/faqs/59317>
[Answer]
# ~~134~~ 133 characters
Note: I don't know for sure whether a line-break counts as 1 character.
```
0N=RND(10)+1:DIMT$(2):T$(0)="TOO LOW.":T$(1)="CORRECT.":T$(2)="TOO HIGH."
1I."WHAT'S MY NUMBER? (1-10) ",G:?T$(SGN(G-N)+1):IF G-N T.1
```
### Example output
[](https://i.stack.imgur.com/7lC1r.png)
] |
[Question]
[
>
> Have you been shooting gallery? We are recently.
>
>
>
In our shooting gallery cans and aluminum cans from under various drinks hang and stand. More precisely, they hung and stood.
From our shots, banks dangled from side to side on a rope, were torn off, rang, crumpled. This is not for you to shoot from your fingers.
Each of the bullets either went right through one of the cans, after which the affected can fell to the floor and rolled away so that it was no longer possible to get into it; or didn’t hit any of the cans. In any case, each of the bullets was stuck in the wall behind our target cans.
But that day is past. There was only a wall with bullets stuck in it and a photograph. In an attempt to restore that day and enjoy it again, we collected data on the position of each bullet in the wall, the location of the cans and the order of the shots.
>
> Help determine about each bullet whether it hit one of the cans, and if it hit, then which one.
>
>
>
**Input format**
The first line contains two integers n and m (1 ≤ m, n ≤ 1000) - the number of cans that were our target on that day, and the number of shots fired that day.
The i-th of the next n lines describes the position of the i-th jar. The position is set by the coordinates of the can’s projection onto the vertical plane. The projection is a rectangle, the sides of which are parallel to the coordinate system applied to this plane. The Y axis of this system is directed vertically upward, and the X axis is horizontally. A rectangle is defined by a pair of points - its left bottom and top right vertices.
>
> It is guaranteed that not a single pair of these rectangles has a single common point.
>
>
>
The i-th of the next m lines describes the position of the i-th bullet in the wall. The bullets are set in the same order in which they left our muzzle. The wall itself is strictly vertical, so we can assume that the position is given by the coordinates of the projection of bullets on a vertical plane. Moreover, the trajectories of the bullets were strictly perpendicular to this plane. The points themselves are defined by a pair of coordinates in the coordinate system already described above.
>
> The distance between the banks and the wall compared to the distance to the shooters is so small that we neglect it.
>
>
>
**Output format**
In the first and only line print m numbers, the i-th of which says which of the cans the i-th bullet went through, if any. If i didn’t hit any banks, print -1, otherwise print the serial number in the input of the bank, which was struck by the ith bullet.
```
Sample Input:
4 10
0 0 1 1
2 3 3 8
15 15 20 20
10 12 12 13
2 2
0 -1
23 18
13 12
10 13
16 16
17 17
3 5
3 5
3 3
Sample Output:
-1 -1 -1 -1 4 3 -1 2 -1 -1
```
Here is a representation of the positions in the above sample - the original locations of the four cans `1` - `4`, and the ten bullet locations `a` - `j` - note that `i` is actually in the same location as `h` (`(3,5)`) and that a row is shown for `y=-1` due to `b`:
```
. . . . . . . . . . . . . . . 3 3 3 3 3 3 . . .
. . . . . . . . . . . . . . . 3 3 3 3 3 3 . . .
. . . . . . . . . . . . . . . 3 3 3 3 3 3 . . c
. . . . . . . . . . . . . . . 3 3 g 3 3 3 . . .
. . . . . . . . . . . . . . . 3 f 3 3 3 3 . . .
. . . . . . . . . . . . . . . 3 3 3 3 3 3 . . .
. . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . e 4 4 . . . . . . . . . . .
. . . . . . . . . . 4 4 4 d . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . .
. . 2 2 . . . . . . . . . . . . . . . . . . . .
. . 2 2 . . . . . . . . . . . . . . . . . . . .
. . 2 2 . . . . . . . . . . . . . . . . . . . .
. . 2 h . . . . . . . . . . . . . . . . . . . .
. . 2 2 . . . . . . . . . . . . . . . . . . . .
. . 2 j . . . . . . . . . . . . . . . . . . . .
. . a . . . . . . . . . . . . . . . . . . . . .
1 1 . . . . . . . . . . . . . . . . . . . . . .
1 1 . . . . . . . . . . . . . . . . . . . . . .
b . . . . . . . . . . . . . . . . . . . . . . .
```
Hence `e` struck `4`, `f` struck `3`, and `h` struck `2` (while `g`, `i`, and `j` would have struck cans if those cans had not already fallen to the floor):
```
a b c d e f g h i j
-1 -1 -1 -1 4 3 -1 2 -1 -1
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), (19?) 39 bytes
The entire second line is dealing with the strict I/O spec currently in place, while the 19 byte first line is a dyadic Link performing the core of the challenge. Also if `0` were allowed where `-1` is currently required save the `o-` for -2 bytes.
```
r/p/ċɗ€ⱮT€Ḣ€ŒQa"$o-
ỴḲ€VḢḢ‘œṖƲŒH€€1¦ç/K
```
**[Try it online!](https://tio.run/##y0rNyan8/79Iv0D/SPfJ6Y@a1jzauC4ESD3csQhIHp0UmKikkq/L9XD3loc7NgFFwoASILmGGUcnP9w57dimo5M8QLqa1hgeWnZ4ub73////TRQMDbgMFAwUDBUMuYwUjIHQgsvQVAGIjAyAiMsQKGUERsZAeSOgWl2gQmMFQ6AyIGkEVmDMZWimYGjGZWiuYGjOZaxgCsXGAA "Jelly – Try It Online")**
] |
[Question]
[
**This question already has answers here**:
[Print the previous answer in reverse - with a catch (pt. 2)](/questions/187674/print-the-previous-answer-in-reverse-with-a-catch-pt-2)
(7 answers)
Closed 4 years ago.
Your challenge is very simple: output the previous answer, in reverse.
However, as with [this](https://codegolf.stackexchange.com/questions/161757/print-the-previous-answer) similarly-titled question, there's a catch: in this case, you can only use characters from the answer *before* the last. For example:
Let's say the first answer looks like this:
>
> 1 - Python
>
>
> `print('hi!')`
>
>
>
And the second answer looks like this: (see 'Chaining' section for more info)
>
> 2 - Javascript
>
>
> `console.log(")'!ih'(tnirp")`
>
>
>
Now, it would be my job to write the third answer: a program to output the text `)"print('hi!')"(gol.elosnoc`, while only using the characters `p`, `r`, `i`, `n`, `t`, `(`, `'`, `h`, `i`, `!` and `)`. I can choose whatever language I like to complete this task.
# Chaining
The first answer can output any text: but it *must* **output** *something*. The second answer should simply output the first answer in reverse, using any characters you like. The further rules about restricted characters, as described above, come into play from the third answer onwards.
# Scoring
Your score is \$\frac{l\_{n}}{l\_{n-1}} + l\_{n-2}\$, where \$l\_x\$ represents the length of the \$x\$th answer, and \$n\$ is the position your answer is at in the chain. (all lengths are in bytes; if your answer is no. 1 or no. 2 then miss out \$l\_{n-1}\$ and/or \$l\_{n-2}\$ where necessary.
Best (lowest) score by August 1st wins.
# Formatting
Please format your post like this:
```
[Answer Number] - [language]
[code]
(preferably a TIO link)
SCORE: [Submission Score]
(notes, explanations, whatever you want)
```
*Everything in square brackets is a required argument to fill in; everything in normal brackets is an optional argument; everything not in brackets is there to make the snippet work.*
# Rules
* All characters, etc. are case sensitive.
* Preceeding/trailing whitespace is allowed, within reason (I'm looking at you, Whitespace).
* Every submission must be a unique language.
* You must wait at least 1 hour before submitting a new answer if you have just posted.
* You may **NOT** submit two answers in a row, you must wait for TWO more submissions before posting a new answer.
* Of course, [standard loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) are disallowed.
* Please make sure to triple check that your answer is valid. ~This is especially important, because someone may start writing their answer based on yours, so if it's wrong you can't really edit it any more... and the whole chain breaks down.~ Also, you can't edit answers for continuity purposes.
* Standard I/O methods are allowed.
# Answer list/used languages
```
$.ajax({
type: "GET",
url: "https://api.stackexchange.com/2.2/questions/187667/answers?site=codegolf&filter=withbody&sort=creation&order=asc",
success: function(data) {
for (var i = 0; i < data.items.length; i++) {
var temp = document.createElement('p');
temp.innerHTML = data.items[i].body.split("\n")[0];
try {
temp.innerHTML += " - <i>Score: " +
data.items[i].body
.split("SCORE")[1]
.split("\n")[0]
.split(":")[1]
.trim() +
"</i>";
} catch (TypeError) {
temp.innerHTML += " (no score)";
} finally {
$('#list').append('<li><a href="/a/' + data.items[i].answer_id + '">' + temp.innerText || temp.textContent + '</a>');
}
}
}
})
```
```
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<base href="https://codegolf.stackexchange.com">
<ul id="list"></ul>
```
[Answer]
# 3 - Python 2
419/64+57 -> **SCORE: 63.546875**
This is one masterpiece of hackery. ~~Edited to comply with rule 1.~~ chr uses lowercase h, not uppercase. Will edit when I have time to find a substitute.
Update 9/25/2020: Yeah I'm not coming back to this, question is closed anyway.
This is assuming the first answer is Python 3
```
e=ord
o=e("o")
a=e("a")
n=e("\n")
t=e(")")
b=e("(")
i=e("i")
W=e(" ")
p=o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+a+n+n
o=chr
H=o(W+t)
d=o(p+n)
p=o(p)
l=o(a+e(",")+n+n+n)
r=o(i+t+t)
c=o(b+b+b+n+W)
print(o(b+W+n)+r+l+p+")c("+p+p+c+d+p+H+p+""""!" + b + " ," + a = c"""+p+H+p+""""dlroW" = b"""+p+p+""""olleH" = a"""+p)
```
[TIO](https://tio.run/##zY8xDsMgDEV3TkE9gZytM3tuwNKFQKQiIUCIpaen38nSIxQL/PT4SLh/5rvV51qnayOp5k5DjawKAgFQBV4VNIUs4BAAqiyQAV5AA7pr/G8VuHLFZPE91O6a8TytSoDO9fqx6VYVtMCYYiMrebkacJmnxCPwYKnKHo9GrtOI8gjy4MKdyUZD6J0jJ5y7OKwHadYHNulNMGinI/xPJJXRPMEft79tK@XcxYbL2rW@)
[Answer]
# 2. [05AB1E](https://github.com/Adriandmen/05AB1E)
```
“a = "Hello"““b = "World"“I“c = a + ", " + b + "!"“I“…¢““(c)“«»R
```
[Try it online!](https://tio.run/##yy9OTMpM/f//UcOcRAVbBSWP1JycfCUgD4iSQALh@UU5KSABTyBOBookKmgrKOkoKAGpJBBTESb5qGHZoUUQnRrJmkDy0OpDu4P@/wcA "05AB1E – Try It Online")
---
```
64/57 + 0 = 1.12
```
### SCORE: 1.12
[Answer]
# 1 - Python
```
a = "Hello"
b = "World"
c = a + ", " + b + "!"
print(c)
```
[Try it online!](https://tio.run/##K6gsycjPM/7/v6AoM69EQ90jNScnX0chPL8oJ0VRXfP/fwA)
**SCORE: 57**
First answer.
] |
[Question]
[
# Challenge:
Given two inputs, **x** and **y**, round **x** to one less significant figure, then repeat until it has **y** number of unrounded digits left. (the decimal point does not count as a digit)
# Input & Output
Input can be a combination of strings and integers, e.g. you can have the input as a string and the output as an int, or vice versa.
The input number will never have 15 digits total, and the y will never be greater than the input number's length and will always be greater than 0.
Example:
```
x = 32.64712, y = 3
32.64712 -> 32.6471 -> 32.647 -> 32.65 -> 32.7 (Three unrounded digits left)
x = 87525, y = 2
87525 -> 87530 -> 87500 -> 88000 (Two unrounded digits left)
x = 454, y = 3
454 -> 454 (Three unrounded digits left)
```
(steps shown just to clarify, you only need to output the last value.)
# Rules
* Trailing 0's are allowed
* 5's round up
* Standard loopholes apply
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so you should strive for the shortest answer.
[Answer]
# [Python 2](https://docs.python.org/2/), ~~101~~ ~~97~~ ~~92~~ ~~91~~ 85 bytes
```
lambda x,y:reduce((lambda n,l:int(n/.1**l+.5)*.1**l),range(15,y+~len(`int(x)`),-1),x)
```
[Try it online!](https://tio.run/##hc69DoIwEADg3ae4xKXFA6FQMST6FIwOoi0/SS2mQoTFV8eCEDddet9dej/3vilrzYb8cBpUdruIDDrsEyNFe5WEzCWNKql0Q/TWCxxHbTxOnUkUTaYLSQKO/ealpCbn8V9HzxTdgGJHh7uxFchJyLxdFAcMIaSwtu@cg3tc/OUiPiMGSEsjJbTa1K0WUoCoiqp5gJJ5s1p27GPOOLJp/uSx3SL0Z/gf7H2L9Fn/GRfxCD/HWo2NY/hxx/AG "Python 2 – Try It Online")
---
Alternative :
If Python's round would round "half up" instead of "half to even":
# [Python 2](https://docs.python.org/2/), 57 bytes
```
lambda x,y:reduce(round,range(15,y-len(`int(x)`)-1,-1),x)
```
[Try it online!](https://tio.run/##hc7NDoIwDADgu0/RxMuWDMMGE2KiT8HRA@gKkuAgc0R4@jn@4k0v7dcm/elG@2i1cOX56prieVMFDGw8GVT9HYlpe62YKXSFhEs2Bg1qktfakoHmNOAs4JQN1HXG96AkkTgc44QLBhGFvY9rDcFl85eb5IoEIHsYROj1fBcVqLqq7QsaLO1uu5EmUkgm5v2zp3GPKFwRLkhDj@zd/lkXy5gtz3pNg1P68Yf7AA "Python 2 – Try It Online")
[Answer]
## JavaScript (ES6), 58 bytes
```
f=
(x,n,y=x.toPrecision(n))=>y>x?y:(x*9/8-y/8).toPrecision(n)
```
```
<div oninput=o.textContent=f(+x.value,+n.value)><input id=x><input id=n type=number min=1 max=15 value=3><pre id=o>
```
Arithmetic solution. The given procedure rounds numbers up if they are greater than 4/9 of the next value, so if rounding doesn't increase the number, try again with a slightly greater value.
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 59 bytes
```
{($^a,{.round(10**($++-15))}...^0|any 10 X**^30-15)[*-$^b]}
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYKvwv1pDJS5Rp1qvKL80L0XD0EBLS0NFW1vX0FRTs1ZPTy/OoCYxr1LB0EAhQksrztgAJBGtpasSlxRb@784sVIhTcPYSM/MxNzQSEfBWNOaCyJmYW5qZKqjYAQXMDE1Acv/BwA "Perl 6 – Try It Online")
Anonymous code block that takes two numbers and returns a number.
### Explanation:
```
{ } # Anonymous code block
( ... ) # Create a sequence
$^a, # With the first element as the input
{ } # With each element being
.round(10**($++-15)) # The previous element rounded by another digit
0 # Until 0
| # or
any 10 X**^30-15 # Any available power of 10
^ # Ignoring the last number
[*- ] # Index from the end
$^b # The second number
```
[Answer]
# [R](https://www.r-project.org/), 79 bytes
Unfortunately, R uses "round to even" when rounding off a .5
```
function(x,y){for(i in nchar(gsub('\\.','',x)):y){x=signif((x*100+1)/100,i)};x}
```
[Try it online!](https://tio.run/##FYrLDoIwEADvfkVv3dUVaWnF@PgTLkqyuJeSFEhKCN9e62kmk4mZ1fOceQn9LGOARCtuPEYQJUGF/vuOMEzLB3TXVZq0poR4L096TTIEYYB0NHV9MngpIMH9kfbM0Njq6lpjqcEDw6311pP9q/OutPwD "R – Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/), 103 bytes
This is ugly and presumably there are better ways (alas `sprintf`’s `%g` rounds to even), but it works.
```
g=->m,n{m.to_s.size>n ?g[(m/10.0).round,n]:m}
->x,n{_,s,_,e=x.to_d.split
"0.#{g[s.to_i,n]}".to_f*10**e}
```
[Attempt This Online!](https://ato.pxeger.com/run?1=VY7BDkNAFEX3vkKmaYKMwaCkCd35CRGpYjKJQQyJVnxJN5K2H-VvStl09d65797c93w3XXKfjyFQm4SSNLtRdi0AFP9Y61pagOgVeNKna3PVnQnxVJ_BcmCorWKOOH1kfileSCgxzdCRLqOm6soUltGZjYLq94s3hhzGMPP6NZMiXhe0FYCODgMJ-arRxT6CdcsVQ1eUbNzrTFkQajEIgYnRyXIMvHxoRpvkOja2F8Y7W7b1u27RadrmFw)
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/145129/edit).
Closed 6 years ago.
[Improve this question](/posts/145129/edit)
[Siteswap](https://en.wikipedia.org/wiki/Siteswap) is a notation for juggling patterns.
The other [siteswap puzzle](https://codegolf.stackexchange.com/questions/25178/juggling-by-numbers) is great and it explains siteswap in greater detail than here. This puzzle is meant to be a bit simpler! Numberphile recently [interviewed](https://youtu.be/7dwgusHjA0Y) Colin Wright which helped develop the notation. The part at [~16min](https://youtu.be/7dwgusHjA0Y?t=15m51s) will be useful for this challenge. Another resource which may be useful for wrapping your hear around siteswap if you have not used it before: [In your head](http://www.siteswap.org/validate.html)
Below is the diagram(courtesy of wikipedia) for valid throws with 3 balls and a max height of a throw of 5. A valid siteswap ends at the same position as it started.
[](https://i.stack.imgur.com/3aosx.png)
A valid siteswap for the case we are interested in is defined as follows: In the diagram above choose a starting node and then follow the arrows and write down the number attached to the arrow. If you end up on the same node as you started then the number you have written down is a valid siteswap, otherwise it is not valid.
### Challenge
Take a number as input and output a truthy value if it is a valid siteswap for juggling with 3 balls with a max height of 5, otherwise output a falsy value. (No multiplex throws are allowed)
### Examples
```
Input Output
------------------------
3 True
3333333333 True
3342 True
441 True
5 False
225225220 False
332 False
```
* [Loopholes that are forbidden by default](https://codegolf.meta.stackexchange.com/q/1061/29750) are not allowed.
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so fewest bytes wins.
[Answer]
# [Python 2](https://docs.python.org/2/), ~~204~~ ~~195~~ ~~188~~ ~~174~~ ~~149~~ 144 bytes
```
lambda s:any(i==reduce(lambda C,c:int('40WW75W5AA47WW07W4WW54A0WWAA70A5WAA123896W'.replace('W','A'*3)[C::11][int(c)],16),s,i)for i in range(10))
```
[Try it online!](https://tio.run/##VYxBDsIgEEX3noIdYIgBCqJNuiAeYhbqAitVkkobWheeHqsxWic/mbyfmdc/xmsXZW6qQ27d7XR2aChdfJBQVcmf77Unn3rH6jLEkWDFAYwGba0yANyAAtDKTq21hls9LSGLzXYNeJV837rJgQEzbPGyoPtdWQpx3L9UNT0ysaZsYIE2XUIBhYiSixdPBKc092m6Qg3BBaaLH3znv1VyzkqJOeo5SKnf4f@C139@Ag "Python 2 – Try It Online")
] |
[Question]
[
**This question already has answers here**:
[Determine whether strings are anagrams](/questions/1294/determine-whether-strings-are-anagrams)
(162 answers)
[Manage Trash So](/questions/74164/manage-trash-so)
(36 answers)
Closed 6 years ago.
# Skat
I'm a fan of anagrams, so given two strings `s1` and `s2` write a program or function that outputs a truthy value if `s2` is an anagram of `s1`, and a falsey value otherwise (not accounting for spaces and capital letters).
For example:
Input: `s1 = "Anagram"; s2 = "Nag a ram"`
```
true
```
Input: `s1 = "stack overflow"; s2 = "fewer kool cats"`
```
false
```
Input: `s1 = "apple rocks"; s2 = "paler spock"`
```
true
```
# Rules
* Program and function allowed.
* Shortest code in bytes wins.
Duck logo!
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 8 bytes
```
lðδKJ€{Ë
```
[Try it online!](https://tio.run/##MzBNTDJM/f8/5/CGc1u8vR41rak@3P3/f7S6Y15ielFirrqOgrpfYrpCogKIEwsA "05AB1E – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 8 bytes
```
ŒlḟṢ¥€⁶E
```
[Try it online!](https://tio.run/##y0rNyan8///opJyHO@Y/3Lno0NJHTWseNW5z/f//f7S6Y15ielFirrqOgrpfYrpCogKIEwsA "Jelly – Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), 74 bytes
```
def f(a,b):print(g(a)==g(b))
g=lambda a:sorted(a.upper().replace(" ", ""))
```
[Try it online!](https://tio.run/##FcgxDsMgDADAva@wPNlSlKVbJMY8xARDkSAgh0bq62l74/XPeLXzOWfQCJFk8bx1y@egRMLOJfLMj@SKVB8EZLuaDQ0k67t3NeLVtBc5lBBwAUTmGQmr2NHgzkPK/u87Q1GoAr81GII8vw "Python 3 – Try It Online")
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 13 bytes
```
v rS á øVv rS
```
[Test it](http://ethproductions.github.io/japt/?v=1.4.5&code=diByUyDhIPhWdiByUw==&input=IkFuYWdyYW0iCiJOYWcgYSByYW0i)
] |
[Question]
[
## Task
The task is to write a script that accepts a number from 1 to 20 inclusive. It will then check if the number has a character that is found in every number that was entered before it. If the number has a character in common it will ask for another number. However if the number does not have a character in common with any of the previous numbers the program will halt
You are given the following array which is named as numbers
```
{"one","two","three","four","five","six","seven","eight","nine","ten","eleven","twelve","thirteen","fourteen","fifteen","sixteen","seventeen","eighteen","nineteen","twenty"}
```
### Example runs
Say the following number is given
```
1
```
There are no previous numbers so it shares a character will every previous number. So the program will ask for another number, let the following number be given
```
3
```
one and three both share the character "e" so this is a valid number. So we given another number, let the following number be given
```
4
```
four does not share the "e" common to both one and three so this breaks the pattern so the program now stops
Here is another run with just the output of the program shown
```
5
15
17
3
7
8
2
```
This script also had the pattern of numbers with the letter "e" which caused "two" to break the pattern
[Answer]
# [Python 2](http://pypy.org/), ~~48~~ 46 bytes
Saved two bytes thanks to @ovs!
```
s=set(''.join(l))
while s:s&=set(l[input()-1])
```
[Try it online!](https://tio.run/##NYzLasMwEEX3@grVi9qCpuCUkhLIpuAu2w8IWZh0Uk1RJaEZx/HXu3pFiLlnHvf6hbWz241f/LKaw7FxFpqnhmeXqg6QuoubQhK8po7wlipcwUYF/NEc1WIxlqGpW57BZBNrDAx5ltLuiJdKMfROyVo5hxdM@RVjqOWlOa10IOCubZ9/HdrOKCVmjQYk7ekxr8wRrZ@4U5v@pFYOy17I@OowcxiRQL6PBMPtDJ7R2a79dCxHY8qhPDtL0x98P7RKQD6Sw9fHEIILJc@PROur6OPfiRexE29iK/p/ "Python 2 (PyPy) – Try It Online")
Renamed `numbers` to `l`. If that's not okay then add 10 bytes for `l=numbers`.
] |
[Question]
[
When I saw this title in the Hot Network Questions I thought it was going to be a PPCG challenge. I was a little disappointed when it was on [Mathematica](https://mathematica.stackexchange.com/questions/147829/rot13-and-upside-down-text-flip-text).
So now it is on PPCG:
## Challenge
Given an input string, output the [ROT13](https://en.wikipedia.org/wiki/ROT13), flipped value. The input will contain characters from the following alphabet: `[abcdefghijklmnopqrstuvwxyz <flipped alphabet>]`1
The flipped alphabet can be anything visually similar to the flipped lowercase Latin alphabet so long as it can be accepted as input.
The space character should remain unchanged.
As an example, your flipped alphabet might be `zʎxʍʌnʇsɹbdouɯlʞɾᴉɥƃɟǝpɔqɐ`
## Example
```
Input: caesar woz ere
Rot13: pnrfne jbm rer
Output: ɹǝɹ ɯqɾ ǝuɟɹud
Input: ɹǝɹ ɯqɾ ǝuɟɹud
Rot13: pnrfne jbm rer
Output: caesar woz ere
```
## Scoring
Simple [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), the lowest number of bytes wins.
---
I think this is different enough to the [proposed duplicate](https://codegolf.stackexchange.com/posts/125214/edit) for a few reasons:
* The answerer has the choice of which characters to use as output (within limits)
* The process should be reversible. i.e. flipped text should be acceptable as input and return "normal" text.
* There is the opportunity for graphical solutions in this question.
[Answer]
# Mathematica, 234 bytes
```
T=ToExpression;B=Characters;L=T@CharacterRange["a","z"];K=T@B@"uodbɹsʇnʌʍxʎzɐqɔpǝɟƃɥᴉɾʞlɯ";(If[Max@ToCharacterCode@#<123,A=L;F=K,A=K;F=L];S=Association@Table[ToRules[A[[Z]]==F[[Z]]],{Z,Length@L}];Row@Reverse@T@B@#/.S)&
```
[Answer]
# [Python 3](https://docs.python.org/3/), 120 bytes
*many bytes saved thanks to @JonathanAllan*
```
lambda s,a='abcdefghijklmnopqrstuvwxyz VOďƄɹ5ʇη^MXʎ2ɐʠ>Pəɟ6ɥ!ɾʞ|W ':''.join(a[(a.find(c)+27)%54]for c in s)
```
[Try it online!](https://tio.run/##K6gsycjPM/6fZhvzPycxNyklUaFYJ9FWPTEpOSU1LT0jMys7Jzcvv6CwqLiktKy8orJKIcz/SP@xlpM7TU@1n9se5xtxqs/o5IRTC@wCTs48Od/s5FLFk/tOzasJV1C3UlfXy8rPzNNIjNZI1EvLzEvRSNbUNjLXVDU1iU3LL1JIVsjMUyjW/F9QlJlXopGmoZScmFqcWKRQnl@lkFqUqqSpyQWXOtIfdnLnyflhJ2cqAM1fEK4A5M08uROo5j8A "Python 3 – Try It Online")
] |
[Question]
[
In [Rocket League](https://www.rocketleague.com/), there are controls assigned to quick chat. For PC, they are
`1`, `2`, `3`, and `4`. To use a quick chat, you must press two controls. For example, the first option would be `1`, `1`.
You will be simulating the Rocket League client. You will be given a non-empty list composed only of four characters of your choosing. The length of the list will always be even and `<= 8`. I will be using `1, 2, 3, 4` for the examples. If you modify the input domain, you must specify how your input maps to `1, 2, 3, 4`.
The first character in each couplet specifies the section, the second the item in the section. Below are all sections, with their default chat:
```
1
1 I got it!
2 Need boost!
3 Take the shot!
4 Defending...
2
1 Nice shot!
2 Great pass!
3 Thanks!
4 What a save!
3
1 OMG!
2 Noooo!
3 Wow!
4 Close one!
4
1 $#@%!
2 No problem.
3 Whoops...
4 Sorry!
```
The above are case sensitive. So, `1 1` would be `I got it!`, and `3 3` would be `Wow!`.
In addition, after three quick chats come through rapidly, the game shots you down. You get a message back: `Chat disabled for 2 seconds.`. If you continue trying, you get one more chance, and then `Chat disabled for 4 seconds.`. Our challenge will not deal with time, or any further chats.
However, after three chats (6 input characters), you must output `Chat disabled for 2 seconds.`. After four chats (8 input characters), you must output `Chat disabled for 4 seconds.`. Since 8 is the maximum input length, that would be your final output, if they are 8 input characters.
# Input
First, chose your four characters, and map them to `1, 2, 3, 4`.
Your input will be non-empty, contain an even number of items, and only contain up to eight items.
# Output
You will output the matching quick chats in order, plus any `chat disabled` warnings (in the correct location). Output is case sensitive. It must be delimited - suggested delimiters are `\n` (pretty delimiter) or `,`, and you cannot use any delimiters in any of the possible outputs.
# Test Cases
In these, input is in the form of a JSON list and can be `1, 2, 3, 4`, and the output delimiter is `,`.
```
[1, 1, 1, 1] => I got it!,I got it!
[2, 4, 4, 4] => What a save!,Sorry!
[3, 3] => Wow!
[1, 4, 2, 3, 4, 1, 4, 4] => Defending...,Thanks!,$#@%!,Chat disabled for 2 seconds.,Sorry!,Chat disabled for 4 seconds.
```
Invalid (out of scope) inputs:
```
[] //empty
[1, 3, 1] //odd length
[5, 4] //character out of input domain
[1, 2, 3, 4, 1, 2, 3, 4, 1] //length > 8
```
To ensure the point is made: you are not taking these in real time, like in the game. You are just receiving a (short) list of numbers.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~153~~ 150 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
⁶;j@“Kẋ3ŒK!D“¿ṁxṁị»Wḣ
J_2ḤÇ€
s2ḅ4ị“w eɲEƓṫ:⁾ṆƙḅƙḣḊṗṠ,`ė)®=Œf°Ẇŀ#ḍḤḌCṭ8v⁻$ʠṄṾŻYtṫʠßR>ĊḷḊc8Þ@Zq8-@⁻⁺ ḃḊĿ`ÆYƒðḤ|3ƓULẇẇŻịỵ1²ṄE'Cṣ\{ṣ{ḃ⁵ḳpẸz.4<»Ỵ¤µżÇ;/ȦÐfY
```
Input is a list of integers, where `0`, `1`, `2`, and `3` represent `1`, `2`, `3`, and `4` respectively.
Output is a newline separated print out.
**[Try it online!](https://tio.run/nexus/jelly#FY5NS8NAEIbv/RW1CiL40TY9BKsS0F6sJ0ElIlgQe/CkKCrWQ@NHAm0FSQ9FEA2kePGDUo3uZqWF3W7Q/ovZPxJHmHlhZt55ZmJlfeb3DFW9L0JY16RbHFnCgveBWqeYwOqcbQDxE8vbWSBt4aiLl8Q6yiGW1zmco/0kufvbLURNoM@zyuoBtaM7nP6LD6QGtAXUmywNWhP8bV66Zd6B0JbVUSA3yATSWAT6qh8ri40NPaBXQHuSmUeIG3ricXVhUAPyhaAdXTwYmwf6lIFWZYVJIJfYHvRLwjYjV3SQdq5FzbUVCB0MyfA/YEGGd5FaGMcz/lYFpYKLygqAvO9DSM6mc3McrR@8zQP5LZz8zM@TuC2bcRyn0lomq6U1LfUH)**
### How?
There is a compressed string taking up 105 bytes:
```
“w eɲEƓṫ:⁾ṆƙḅƙḣḊṗṠ,`ė)®=Œf°Ẇŀ#ḍḤḌCṭ8v⁻$ʠṄṾŻYtṫʠßR>ĊḷḊc8Þ@Zq8-@⁻⁺ ḃḊĿ`ÆYƒðḤ|3ƓULẇẇŻịỵ1²ṄE'Cṣ\{ṣ{ḃ⁵ḳpẸz.4<»
= "Need boost!\nTake the shot!\nDefending...\nNice shot!\nGreat pass!\nThanks!\nWhat a save!\nOMG!\nNoooo!\nWow!\nClose one!\n$#@%!\nNo problem.\nWhoops...\nSorry!\nI got it!"
```
(Somewhat shockingly 1 byte was saved by including all the `!` rather than inserting them via code.)
The program then works as follows
```
⁶;j@“Kẋ3ŒK!D“¿ṁxṁị»Wḣ - Link 1, get a disabled string: number, seconds
⁶ - space character
; - concatenate with seconds (e.g. " 4")
“Kẋ3ŒK!D“¿ṁxṁị» - compressed list of strings ["Chat disabled for"," seconds"]
j@ - join (swap @arguments) (e.g. "Chat disabled for 4 seconds"
W - wrap in a list
ḣ - head to seconds (for -2 and 0 gives an empty list, for 2 and 4 give the string wrapped in a list)
J_2ḤÇ€ - Link 2, get disabled strings: list of chat strings
J - range of length (e.g. for 4 chat strings [1,2,3,4])
_2 - subtract 2 (...[-1,0,1,2])
Ḥ - double (...[-2,0,2,4])
Ç€ - call last link (1) as a monad for €ach
s2ḅ4ị“...»Ỵ¤µżÇ;/ȦÐfY - Main link: list of characters
s2 - split into twos
ḅ4 - convert from base four (vectorises)
¤ - nilad followed by link(s) as a nilad:
“...» - compressed string described in code-block above
Ỵ - split on newlines
ị - index into (use the base four representation to get the chat strings)
µ - monadic chain separation (call that x)
Ç - call last link (2) as a monad
ż - zip
;/ - flatten list by one level
Ðf - filter keep if:
Ȧ - any and all (false for empty results, i.e. the empty results from link 2)
Y - join with newlines
- implicit print
```
[Answer]
# JavaScript, 264 bytes
```
f=([x,y,...z],n=.5)=>"I got it!,Need boost!,Take the shot!,Defending...,Nice shot!,Great pass!,Thanks!,What a save!,OMG!,Noooo!,Wow!,Close one!,$#@%!,No problem.,Whoops...,Sorry!".split`,`[x*4+y-5]+(n>1?`,Chat disabled for ${n} seconds.`:'')+(z[0]?','+f(z,n*2):'')
```
] |
[Question]
[
**This question already has answers here**:
[Fluctuating ranges](/questions/74855/fluctuating-ranges)
(20 answers)
Closed 7 years ago.
This is a fairly simple challenge. Given a lower-case word, you must "interpolate" between letters. Here's some examples to hopefully clarify this:
Input: `test`
Output: `tsrqponmlkjihefghijklmnopqrst`
Between letters you must add, in alphabetical order, the letters between those two letters. So if you have `ad`, you must output `abcd`. If you are given `da`, you must output `dcba`.
If the letters are next to each other in the alphabet, nothing happens:
Input: `hi`
Output: `hi`
Assume the input contains a lower-case word consisting of ASCII letters only; no spaces, symbols, etc. The input is also never empty.
Lowest byte count wins; this is code-golf. If you have any questions please comment.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 4 bytes
```
ÇŸçJ
```
[Try it online!](https://tio.run/nexus/05ab1e#@3@4/eiOw8u9/v/PSCzOBgA "05AB1E – TIO Nexus")
Honestly? I don't know why this works.
```
Ç # Push characters as ASCII.
Ÿ # Supposed to be range from [a, .., b], apparently vectorizes on lists...
çJ # Turn back into characters, join stack.
```
] |
[Question]
[
The goal is to output the number of the months given as input in a compact concatenated form which is still parsable if one knows the construction rules:
If either:
* January is followed by January, February, November or December; or
* November is followed by January or February
There must be a separator placed between.
Otherwise there should be no separator.
As such the output may be parsed. For example:
* **March, April and September** -> `349`
* **January, January and February** -> `1-1-2`
* **January, January and December** -> `1-1-12`
* **January, November and February** -> `1-11-2`
* **November, January and February** -> `11-1-2`
* **November and December** -> `1112`
Thus any run of ones is either a run of Novembers, a run of Novembers followed by a December, a run of Novembers followed by an October, or a January followed by an October. This may be parsed by looking to the right of such runs as the resulting string is read from left to right.
# Input
A list of months numbers (`[1-12]`) in any format you want (list, JSON, separated by one or more characters, entered one by one by user, …).
the same month can be present more than once.
# Output
The compact concatenated form described above. If a separator is needed, you can freely choose one.
Output examples for **January, February and March (1-2-3)**:
* `1-23` (chosen for the test cases below)
* `1 23`
* `1/23`
* `1,23`
* ...
# Test cases
```
[1] => 1
[1, 2] => 1-2
[2, 1] => 21
[12] => 12
[1, 11] => 1-11
[11, 1] => 11-1
[1, 1, 1] => 1-1-1
[2, 11] => 211
[11, 2] => 11-2
[1, 2, 3] => 1-23
[11, 11] => 1111
[1,1,11,1,12,1,11,11,12] => 1-1-11-1-121-111112
[10,11,12,11,11,10,1,10,1,1] => 1011121111101101-1
[2,12,12,2,1,12,12,1,1,2,12,12,2,11,2,12,1] => 2121221-12121-1-21212211-2121
```
# Rules
* As usual, this is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), shortest answer in bytes wins.
* [Standard loopholes](https://codegolf.meta.stackexchange.com/q/1061/42963) are forbidden.
[Answer]
# [Python 2.7](https://www.python.org/download/releases/2.7/) 96 bytes
## [Try it out here!](http://ideone.com/70XYzw "you can edit the code to try different inputs!")
### Huge thanks to [Jonathan Allan](https://codegolf.stackexchange.com/users/53748/jonathan-allan) for shortening the answer.
### golfed:
```
b,o=input(),""
for a,n in zip(b,b[1:]):o+=`a`+"-"*(a%10==1and a+n in(2,3,12,13))
print o+`b[-1]`
```
### Explanation:
runs through the input, checks if the current item is a special case and if so handles it, otherwise just concatenates the input, prints the output string.
### ungolfed:
```
input = [2,12,12,2,1,12,12,1,1,2,12,12,2,11,2,12,1]
output = ""
for i in range(len(input) - 1):
next = input[i + 1]
item = input[i]
if item == 1 and (next == 1 or next == 2 or next == 11 or next == 12) or item == 11 and (next == 1 or next == 2):
output += str(item) + "-"
else:
output += str(item)
output += str(input[-1])
print output
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 20 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
%⁵=1a+e“£¤€Æ‘⁶ẋ⁸,⁹µ/
```
**[TryItOnline!](http://jelly.tryitonline.net/#code=JeKBtT0xYStl4oCcwqPCpOKCrMOG4oCY4oG24bqL4oG4LOKBucK1Lw&input=&args=WzIsMTIsMTIsMiwxLDEyLDEyLDEsMSwyLDEyLDEyLDIsMTEsMiwxMiwxXQ)** or [run all test cases](http://jelly.tryitonline.net/#code=JeKBtT0xYStl4oCcwqPCpOKCrMOG4oCY4oG24bqL4oG4LOKBucK1LwrDh-G5hCTigqzhuZvigJw&input=&args=W1sxXSxbMSwyXSxbMiwxXSxbMTJdLFsxLDExXSxbMTEsMV0sWzEsMSwxXSxbMiwxMV0sWzExLDJdLFsxLDIsM10sWzExLDExXSxbMSwxLDExLDEsMTIsMSwxMSwxMSwxMl0sWzEwLDExLDEyLDExLDExLDEwLDEsMTAsMSwxXSxbMiwxMiwxMiwyLDEsMTIsMTIsMSwxLDIsMTIsMTIsMiwxMSwyLDEyLDFdXQ)
### How?
```
%⁵=1a+e“£¤€Æ‘⁶ẋ⁸,⁹µ/ - Main link: the list
/ - reduce
µ - monadic chain separation
%⁵ - left item mod 10
=1 - equal to 1? (Jan or Nov)
a - and
+ - left item plus right item
e - is in
“£¤€Æ‘ - jelly code page index list: [2,3,12,13]
now True (1) for any of:
[1,1], [1,2], [1,11], [1,12], [11,1], or [11,2]
⁶ - literal space (the separator being used)
ẋ - repeated that many times
⁸ - left argument
, - pair
⁹ - right argument
```
] |
[Question]
[
I am in desperate need of some ear defenders, so I can program in peace. Unfortunately, I don't have ear defenders. But I do have a pair of headphones, a microphone and a microcontroller, so I thought I'd make some noise-cancelling headphones.
However, there is one tiny problem. I can't program in noisy environments! So you'll need to write the code for me.
## Task
Given a constant noisy input, output the input's "complement"; a value that will completely cancel out the input value (`0x00` cancels `0xff`, `0x7f` cancels `0x80`). Because the headphones block *some* noise, also take a value as input that you will divide the "complement" by, using the following algorithm: [`if (c < 0x80) ceil ( 0x7f - ( (0x7f - c) / n ) ) else floor ( ( (c - 0x80) / n ) + 0x80 )`](//jsfiddle.net/wizzwizz4/Lovu4gqe/) where `c` is the "complement" and `n` is the value to divide by. (If the value exceeds the byte range, it should be clipped to `0` or `255`.)
The input will always be a sequence of bytes, via `stdin` or function parameter (see bonuses) but the modifier can be given via any input method. The output sequence should be output via `stdout` or as a return value (see bonuses). The output should be a series of bytes (e.g. `$.d<±3Ç/ó¢`), or a set of numbers representing those bytes (e.g. `217 135 21 43 126 219`).
Oh, and your code will have to be short, because there isn't much flash memory on the microcontroller (4096 bytes; and I need to fit on drivers too!).
## Examples
In these examples, I have used hexadecimal codes to represent bytes, because `DEL` and `NULL` are somewhat hard to read. The actual input and output should be done as a string of bytes or as a byte-stream.
Modifier: `2`
Input: `0x00 0x10 0xe0` ...
Output: `0xbf 0xb7 0x4f` ...
Modifier: `128`
Input: `0x00 0x10 0xe0` ...
Output: `0x80 0x80 0x7f` ...
Modifier: `0.5`
Input: `0x00 0x10 0xe0` ...
Output: `0xff 0xff 0x00` ...
Your code should cope with much longer inputs than this; these are just examples.
## Bonuses
To add a bonus to a score, use the following formula: `s * (100% - b)` where `s` is the current score and `b` is the bonus as a percentage.
* 1% If you output as raw bytes.
* 5% If there's no `stdin` pipe (or byte input), get the bytes straight from the microphone, [such as with `parec`](https://unix.stackexchange.com/questions/269490/which-special-file-holds-microphone-input).
* 5% If you output to the speakers as well as returning / outputting to `stdout`.
[Answer]
# Pyth, ~~54~~ 51 bytes
```
J128m.MZ,0h.mb,255?<dJ.E-tJc-tJdQs+c-dJQJm-255id16E
```
[Try it here!](http://pyth.herokuapp.com/?code=J128m.MZ%2C0h.mb%2C255%3F%3CdJ.E-tJc-tJdQs%2Bc-dJQJm-255id16E&input=128%0A%5B%220x00%22%2C%220x10%22%2C%220xe0%22%5D&test_suite=1&test_suite_input=2%0A%5B%220x00%22%2C%220x10%22%2C%220xe0%22%5D%0A128%0A%5B%220x00%22%2C%220x10%22%2C%220xe0%22%5D%0A0.5%0A%5B%220x00%22%2C%220x10%22%2C%220xe0%22%5D&debug=0&input_size=2)
## Explanation
```
J128m.MZ,0h.mb,255?<dJ.E-tJc-tJdQs+c-dJQJm-255id16E # Q = modifier, E = input list
J128 # set J to 128
m E # map each input d
id16 # convert to decimal
-255 # get the complement
m # map each complement d
?<dj # if d < 128
.E-tJc-tJdQ # use the ceil-formula
s+c-dJQJ # otherwise use the floor-formular
.mb,255 # minimum of the result and 255
.MZ,0h # maximum of the result and 0
```
] |
[Question]
[
This challenge is inspired by [this other](https://codegolf.stackexchange.com/questions/71203/convert-the-time-to-a-string).
# The challenge
Write a program or a function in any programming language that given as input a string representing a time in English (see below, for further details) it outputs or prints the equivalent in the 24 hours "digital" format HH:MM.
Shortest code in bytes wins, [standard loopholes](http://meta.codegolf.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) are forbidden.
# Input format
Your program should be able to handle all this kind of inputs:
```
one minute past 'HOUR'
'MINUTES' minutes past 'HOUR'
quarter past 'HOUR'
half past 'HOUR'
one minute to 'HOUR'
'MINUTES' minutes to 'HOUR'
quarter to 'HOUR'
'HOUR'
'HOUR12' 'MINUTES' AM
'HOUR12' 'MINUTES' PM
```
where: `MINUTES` is a number from 1 to 59 written in English with hyphen; `HOUR` is the name of an hour in one of the formats:
```
midnight
noon
midday
'HOUR24' o'clock
'HOUR12' o'clock AM
'HOUR12' o'clock PM
```
`HOUR12` is a number from 1 to 12 written in English with hyphen; and `HOUR24` is a number from 1 to 23 written in English with hyphen.
# Some examples
```
midnight -> 00:00
midday -> 12:00
twelve o'clock -> 12:00
quarter to midnight -> 23:45
twenty-two minutes past eight o'clock PM -> 20:22
thirty-four minutes to fifteen o'clock -> 14:26
six o'clock AM -> 06:00
one minute to twenty-one o'clock -> 20:59
seven thirteen AM -> 07:13
nine fourteen PM -> 21:14
```
Good luck!
[Answer]
# Ruby, ~~653~~ 597 Bytes
```
P=/ past | to /;T=%w{q twen thirty fourty fifty sixty el twe thi fourte fifte sixt sevent eighte ninet o tw th fo fi si s e n t}.zip([15,*(2..6).map{|i|i*10},*11..19,*1..10]).to_h;D={'middnight'=>0,'midday'=>12,'noon'=>12};n=->s{s.split('-').reduce(0){|p,v|(Array(T.find{|k,_|v.start_with? k}).last||0)+p}};i=->s{m=0;s=s.gsub(/^\s+|\s+$/,'');c=s.split(P);(c.reverse! if s.match(P));h=D[c[0]]||n.(c[0].gsub(/ o\'clock (A|P)m/,''));h+=(s.end_with?('PM') ? 12 : 0);m=n.(c[1]||c[0].split(' ')[1]) if c[1]||c[0].match(/^\w+ (?!o'clock)/);(m=60-m;h=(h-1)%24)if s.match(/ to /);(sprintf '%02d:%02d',h,m)}
```
Ungolfed:
```
P=/ past | to /
# configuration for translating english words to numbers
T=%w{q twen thirty fourty fifty sixty el twe thi fourte fifte sixt sevent eighte ninet o tw th fo fi si s e n t}.zip([15,*(2..6).map{|i|i*10},*11..19,*1..10]).to_h
D={'middnight'=>0,'midday'=>12,'noon'=>12}
# proc for translating english word groups to a number
n=-> s {
s.split('-').reduce(0) { |p,v|
(Array(T.find {|k,_| v.start_with? k}).last || 0) + p
}
}
i=-> s {
m=0
s=s.gsub(/^\s+|\s+$/,'')
c=s.split(P)
(c.reverse! if s.match(P))
# set the hour
h=D[c[0]]||n.(c[0].gsub(/ o\'clock (A|P)m/,''))
h+=(s.end_with?('PM') ? 12 : 0)
# set the minute
m=n.(c[1]||c[0].split(' ')[1]) if c[1]||c[0].match(/^\w+ (?!o'clock)/)
# adjust for 'past'
(m=60-m;h=(h-1)%24)if s.match(/ to /)
sprintf '%02d:%02d',h,m
}
```
Verification script used:
```
examples = <<EXAMPLES
midnight -> 00:00
midday -> 12:00
twelve o'clock -> 12:00
quarter to midnight -> 23:45
twenty-two minutes past eight o'clock PM -> 20:22
thirty-four minutes to fifteen o'clock -> 14:26
six o'clock AM -> 06:00
one minute to twenty-one o'clock -> 20:59
seven thirteen AM -> 07:13
nine fourteen PM -> 21:14
EXAMPLES
examples.split("\n").each do |example|
text, expected = example.split(/\s+->\s+/)
r = i.(text)
raise "Unexpected result for \"#{text}\". Got \"#{r}\", expected \"#{expected}\"" unless r == expected
print "."
end
```
Thank you to Kevin Lau for 47 bytes of optimization
] |
[Question]
[
The purpose of this challenge is to find the general term of a given arithmetic or geometric sequence.
### Explanation
The formula for an arithmetic sequence is as follows
an = a1 + (n-1)d
where a1 is the first term of the sequence, n is the index of the term, and d is the common difference between the terms. For a geometric sequence, the formula for the general term is
an = a1rn-1
where r is the common ratio between the terms of the sequence.
### Challenge
The objective of this challenge is to accept an input of a sequence of numbers, determine whether the sequence is arithmetic or geometric, and then output the formula for the general term. The rules are
* The input will be either a geometric sequence or an arithmetic sequence, nothing else
* The formula can either be returned from a function, or printed to STDOUT or an equivalent
* The input can be taken in any form that is convenient; for example, it could be an argument, taken from STDIN, or hardcoded if the language offers no other way of accepting input
* The input will always be in the format `[3, 4, 5, 6]`, with brackets surrounding comma-separated terms. The spaces separating the terms and the commas are optional. The input will always contain three or more terms.
* The shortest code in bytes wins
### Test cases
```
Input Output
[-2, 0, 2, 4, 6, 8] -2 + 2(n-1) or an equivalent expression
[27, 9, 3, 1, 1/3] 27(1/3)^n-1 or an equivalent expression
[200, 240, 280, 320] 200 + 40(n-1) or an equivalent expression
[2, 6, 18] 2(3)^n-1 or an equivalent expression
```
### Bonus
*-20%*
If your answer outputs a simplified version of the formula; for example, it prints
```
6n-2
```
rather than
```
4 + 6(n-1)
```
*-30 bytes*
If your answer prints the 20th term of the sequence, in addition to the general term.
If your answer satisfies both of these conditions, the 20% is removed first, and then the 30 bytes are removed.
[Answer]
# Mathematica, 75 \* 0.8 - 30 = 30 bytes
```
f=Simplify[FindSequenceFunction@{If[2#2==#+#3,2#-#2,#^2/#2],##}/@{n+1,21}]&
```
Test cases:
```
f[-2, 0, 2, 4, 6, 8]
(* {2 (-2 + n), 36} *)
f[27, 9, 3, 1, 1/3]
(* {3^(4 - n), 1/43046721} *)
f[1, 1, 1]
(* {1, 1} *)
```
In Mathematica, `FindSequenceFunction` is a very interesting function.
```
FindSequenceFunction[{1, 1, 2, 3, 5, 8, 13}, n]
(* Fibonacci[n] *)
FindSequenceFunction[{1+a, 1+a^2, 1+a^3, 1+a^4}, n] (* symbolic! *)
(* 1 + a^n *)
```
[Answer]
# ùîºùïäùïÑùïöùïü 2, 38 chars / 57 bytes
```
î+(x=ì-í≔í-î?`+⟮(n-1)`⟯+(í-î):`(⦃í/î})^Ⅰ
```
`[Try it here (Firefox only).](http://molarmanful.github.io/ESMin/interpreter2.html?eval=true&input=%5B-2%2C%200%2C%202%2C%204%2C%206%2C%208%5D&code=%C3%AE%2B%28%C3%AC-%C3%AD%E2%89%94%C3%AD-%C3%AE%3F%60%2B%E2%9F%AE%28n-1%29%60%E2%9F%AF%2B%28%C3%AD-%C3%AE%29%3A%60%28%E2%A6%83%C3%AD%2F%C3%AE%7D%29%5E%E2%85%A0)`
First answer! I'm still working on bonuses.
# Explanation
```
î+(ì-í≔í-î?`+⟮(n-1)`⟯+(í-î):`(⦃í/î})^Ⅰ // implicit: î=input1, í=input2, ì=input3
î+ // Prepend a1
(ì-í≔í-î // Is rate of change constant from term to term?
?`+⟮(n-1)`⟯+(í-î) // arithmetic mean template
:`(⦃í/î})^Ⅰ // geometric mean template
// implicit output
```
NOTE: `⟮` and `⟯` are copy-paste blocks; anything within those blocks is stored to be called for later pasting (using `Ⅰ`).
[Answer]
## Python, 130\* 0.8 - 30 = 74 bytes
Been a while since I last answer a question and this one has been sitting in my favourites for some time!
Started at **188**
`def m(t):s=str;a=t[0];b=t[1];r=b/a;q=b-a;return((s(q)+'n'+'+'*(0<a-q)+s(a-q),a+q*19),(s(b/r)+'('+s(r)+')^n-1',b*r**18))[t[2]/b==r])`
Uses school maths to determine the coeffs and sticks them together and returns the 20th term.
Sample output: `3n-1 59`, where 59 is the 20th term.
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/40359/edit).
Closed 9 years ago.
[Improve this question](/posts/40359/edit)
You a sequence of numbers like this one given to you as a string:
"**1 2 3 4 8 11 19 33 59 154 196 260**"
Create a program (any language) that calculates the smallest outcome you **can't** get by adding two of those numbers together.
The numbers given must be integers, and are always positive.
You can only use each number once.
The answer must be > 0 and a whole number. The given string must contain at least a 1.
Examples of invalid outcomes:
"**1 2 3 4 8 11 19 33 59 154 196 260**"
* 3 *(1 + 2)*
* 54 *(19 + 33 + 8 + 2)*
Example of valid outcome:
"**1 2 7 34 34 78**"
* 4 *(1 + 2 = 3, can't get 4 by adding any numbers.)*
The shortest answer wins, answers can be submitted until october 30th, 18:00 CET.
[Answer]
# Python - ~~104~~ 99
My interpretation:
```
L=map(int,input().split())
k=1
while k in map(sum,[[i,j]for i in L for j in L if i<j]):k+=1
print k
```
I tested it with the input string `0 1 2 3 4 8 11 19 33 59 154 196 260` containing a 0 to avoid the trivial solution 0.
Result:
```
16
```
] |
[Question]
[
You have a matrix of size *m* x *n*.
Each cell in the matrix has a uniformly random integer value *v*, where 0 ≤ *v* < *i*, and *i* ≤ (*m* x *n*). (Meaning, the matrix contains a maximum of *m* x *n* distinct values, but it may have fewer.)
1) Write a function that accepts input values of *m*, *n*, *i*, and returns a matrix that meets the criteria above.
2) Write a second function that accepts the output of the first function as input, and returns the smallest [contiguous submatrix](http://mathworld.wolfram.com/Submatrix.html) that contains every value of *v* (by returning the submatrix itself, or its coordinates). By “smallest” I mean the submatrix containing the fewest cells.
(If it helps you visualize, the original inspiration for this problem was wondering how to find the smallest rectangle within a GIF that contained all the colors in its palette.)
[Answer]
## APL (23 + 56 = 79)
### Function 1 (23):
```
{¯1+⍵⍴(V⍴⍺?⍺)[V?V←×/⍵]}
```
This takes `i` as its left argument and `m n` as its right argument, like so:
```
+mat←8 {¯1+⍵⍴(V⍴⍺?⍺)[V?V←×/⍵]} 5 5
2 4 7 1 3
7 5 6 7 3
3 1 2 4 6
0 4 2 6 1
5 5 0 0 6
```
### Function 2 (56):
```
{⊃V[⍋≢∘∊¨V←V/⍨{∧/⍵∊⍨∪∊M}¨V←⊃,/{↓∘⍵¨¯1+,⍳⍴⍵}¨↑∘⍵¨,⍳⍴M←⍵]}
```
This takes the output from the first function as its right argument, like so:
```
{⊃V[⍋≢∘∊¨V←V/⍨{∧/⍵∊⍨∪∊M}¨V←⊃,/{↓∘⍵¨¯1+,⍳⍴⍵}¨↑∘⍵¨,⍳⍴M←⍵]} mat
7 5 6
3 1 2
0 4 2
```
] |
[Question]
[
The problem appeared on the [2013 SJCNY High School Programming Contest](http://faculty.sjcny.edu/~ProgrammingCompetition/Problems_2013.pdf). It was the last question in the set of problems and no team produced a correct answer during the 2.5 hours they had to work on it. Shortest solution that can handle the full range of inputs with a reasonable run time (say under 2 minutes on a Pentium i5) wins.
**Vases**
Ryan’s mom gave him a vase with a cherished inscription on it, which he often places on his
window ledge. He is moving into a high rise apartment complex and wants to make sure that if the vase falls off the ledge, it won’t break. So he plans to purchase several identical vases and drop them out of the window to determine the highest floor he can live on without the vase breaking should it fall off the window ledge. Time is short, so Ryan would like to minimize the number of drops he has to make.
Suppose that one vase was purchased and the building was 100 stories. If it was dropped out of the first floor window and broke, Ryan would live on the first floor. However if it did not break, it would have to be dropped from all subsequent floors until it broke. So the worst case minimum number of drops for one vase (V=1) and an N story building is always N drops. It turns out that if Ryan’s drop scheme is used, the worst case minimum number of drops falls off rapidly as the number of vases increases. For example, only 14 drops are required (worst case) for a 100 story building if two (V = 2) vases are used, and the worst case number of drops decreases to 9 if three vases are used.
Your task is to discover the optimum drop algorithm, and then code it into a program to
determine the minimum number of drops (worst case) given the number of vases Ryan purchased, V, and the number of floors in the building, N. Assume that if a vase is dropped and it does not break, it can be reused.
Inputs: (from a text file)
The first line of input contains the number of cases to consider. This will be followed by one line of input per case. Each line will contain two integers: the number of vases Ryan purchased, **V**, followed by the number of stories in the building, **N**. **N** < 1500 and **V** < 200
Output: (to console)
There will be one line of output per case, which will contain the minimum number of drops, worst case.
**Sample Input**
```
5
2 10
2 100
3 100
25 900
5 100
```
**Sample Output** (1 for each input)
```
4
14
9
10
7
```
[Answer]
I solved this in excel, as my work machine doesn't have any languages on it. obviously the input/output part doesn't quite match the question... so psuedocode answer :
Setup
```
Array Heights[200][1500]
for v = 1 to 200
Heights[v][1] = 1
for d = 1 to 1500
Heights[1][d] = d
for d = 2 to 200
for d = 2 to 1500
Heights[v][d] = Heights[v-1][d-1] + Heights[v][d-1] + 1
```
'Heights' now contains all the answers within range. (sort of)
Solutions
```
for each input (V,N) :
d = 1
while (d <= 1500) and (Heights[V][d] < N)
d++
print d
```
A few notes:
* if speed is vital the search in the 'solution' part can be replaced with a binary search
* because of the 1500 limit on floors, you never need to consider more than 11 vases. (in fact if V > log2(N+1), then answer is just round up log2(N+1) ) ((ie binary vase drop search))
* There is slight ambiguity in the question regarding the first floor. It says 'if it breaks on the 1st floor, he will live on the 1st floor' which leads to 'if it breaks on the 2nd floor, he will live on the 1st floor regardless of whether or not it breaks on the 1st'...
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/31815/edit).
Closed 3 years ago.
[Improve this question](/posts/31815/edit)
Write a program which, given two positive integers *n* and *x*, will display the *n*-th root of *x* (which is also x1/n) in decimal to an accuracy of 0.00001. The program must output the resulting number in decimal, and it must work for any two numbers *n* and *x*. The variables may be defined in the program, or they may be inputted by the user, but it must work for any two positive integers.
However:
* You may not use any arithmetic operators or bitwise operators (including `+`, `*`, `^`, `>>`, etc.)
* You may not use any built-in math functions (such as `pow()`, `sqr()`, or `add()`).
* No web requests; the program must be completely independent from all outside sources.
Although I tagged this [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), a program with more code that can do the job more than 1 second faster is better. A winning program will be faster than all the other programs *by more than a second*. Time differences of less than 1 second will be considered negligible. If two programs complete within a second of each other, then the one with less code wins.
[Answer]
# JavaScript
This answer doesn't satisfy all the rules, but I'm happy that at least it works. It's valid only for integers greater than one and there's no further precision.
Note that the `+` and `>` operators are used for string concatenation/comparison and the maths is behind the curtain. I hope that the `!` operator doesn't count as "arithmetic" as it operates over booleans.
```
function f(x,n){for(a=(c=',')+Array(x),s=r=c;a>s;r+=c)for(i='',s=r;i!=Array(n);i+=c)s=s.split(c).join(r);return r.slice(1).length}
```
And some tests:
```
> f(125,3)
5
> f(16807,5)
7
> f(4782969,7)
9
```
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/23596/edit).
Closed 7 years ago.
[Improve this question](/posts/23596/edit)
It's time for some quines! Well, sort of. This challenge is to create the smallest program that could move around in memory, i.e. if a program is resident in 2000:0100, the program should move to say, memory address be7a:3470.
## Rules
1. The memory address to move in should be pseudorandom.
2. It's still valid if it's a moving file around in the hard drive.
3. If it jumps around the RAM it should go to another segment in RAM.
I call these programs transposons, after the genes that move all around the DNA of an organism. Happy golfing! Contest ends May 9, 2014.
[Answer]
## Bash, 2 bytes
```
$0
```
Moves itself to a new memory address when it is assigned a new process.
To move to a different spot on the harddrive it takes a few more:
```
cat $0>x
```
[Answer]
# Bash , 12 bytes
Requires root permissions
```
mv /bin/mv ~
```
7 bytes if you already are in /bin
```
mv mv ~
```
[Answer]
**COBOL** (Enterprise COBOL) One 72-character line, 11 significant characters
```
ID DIVISION
```
That's the smallest (source) I can get which can be moved around (unless I need to make it shorter).
To do the moving:
```
ID DIVISION
PROCEDURE DIVISION
CALL "GOLF006"
CANCEL "GOLF006"
CALL "GOLF006"
```
GOLF006 is the name of the stored program. This CALLs the program (using DYNAM compiler option to load the program dynamically), which program then returns to the CALLer having done its work. The second program then CANCELs the CALLed program (confusingly, CANCEL just causes the program to be "removed" from memory) and then CALLs the same program again, so a new one will be loaded.
I suspect the question will be updated soon...
[Answer]
# PHP (shamefully large):
```
<?file_put_contents(dirname($f=__FILE__).'/'.microtime(1).'.php',file_get_contents($f));unlink($f);
```
`file_put_contents($file,$content);`: write a file, create if it doesn't exist
`file_get_contents($file);`: read a file
`dirname($path)`: gives the directory name of a path
`microtime($float)`: returns a timestamp with microseconds (you can use `rand` or `mt_rand` here)
`unlink($file)`: deletes a link to a file, ultimately deleting a file is no other link exists
`__FILE__`: path of the current file being executed.
] |
[Question]
[
Imagine an ordered file set : `file1`, `file2`, ... `fileN`.
Each file is a textual file that is made of lines that have the same format : A concatenation of a fixed-size key (the same among all the file set) and a variable length value.
The merging algorithm is very similar to `UPSERT` :
* To merge 2 files:
+ Iterate on all lines of the first file.
- If the key of the current line is not in the second file, emit the current line.
- If the key of the current line is in the second file, emit *only* the line of the second file
+ For each line of the second file that has a key not present in the first file emit the line of the second file.
* If more than 2 files are to be merged, each file is merged to the result of the previous merge. The result of `merge(file1, file2, file3, file4)` is defined as the result of `merge(merge(merge(file1, file2), file3), file4)`.
As an example, we take the length of the key of `4` :
```
$ cat file1
0010THIS_IS_LINE_1_FROM_FILE1
0011THIS_IS_LINE_2_FROM_FILE1
00A0THIS_IS_LINE_3_FROM_FILE1
$ cat file2
0010THIS_IS_LINE_1_FROM_FILE2
0100THIS_IS_LINE_2_FROM_FILE2
$ cat file3
0100EMPTY_LINE
0011EMPTY_LINE
```
Will result in :
```
$ merge --key-size=4 file1 file2 file3
0010THIS_IS_LINE_1_FROM_FILE2
0011EMPTY_LINE
00A0THIS_IS_LINE_3_FROM_FILE1
0100EMPTY_LINE
```
Several precisions :
* Textual data is made of printable `ASCII7` chars plus tabs and spaces.
* Preserving order is nice, but not required
* Uniqueness of key is obviously required
* Multicore-aware algorithms are allowed.
* The first file is usually bigger than the others.
[Answer]
# perl, memory-constrained:
Since rubik mentioned it, here's code for when you haven't the memory to keep all of your keys in memory. Basically we just use the filesystem as a dumb key/value store (you could easily use eg DBM or what have you instead).
```
#!/usr/bin/perl -w
use strict;
use warnings;
use File::Spec ();
use File::Path qw(make_path remove_tree);
use File::Glob ':globally';
use Path::Iterator::Rule;
my $key_size = $ARGV[0] =~ /--key-size=(\d+)/ ?
(shift @ARGV, $1) : 4;
my $BASE = File::Spec->catfile( File::Spec->tmpdir(), "merger" );
sub pathify {
my ($key, $mkdirs) = @_;
my @path = ($BASE, split //, $key);
my $dirpart = File::Spec->catdir( @path );
make_path( $dirpart ) if $mkdirs;
return File::Spec->catfile( $dirpart, $key );
}
sub set {
my ($key, $value) = @_;
open my $fh, '>', pathify($key, 1) || die "open(w) $key failed: $!";
print { $fh } $value;
close $fh;
}
sub get {
my ($key) = @_;
open my $fh, '<', pathify($key) || die "open(r) $key failed: $!";
chomp(my $x = <$fh>);
close $fh;
return $x;
}
remove_tree( $BASE );
my %keys;
while(@ARGV) {
my $fn = shift;
open my $fh, "<", $fn || die "can't open $fn for reading: $!";
while(<$fh>) {
chomp;
set( substr($_, 0, $key_size), substr($_, $key_size) );
}
close $fh || die "can't close $fn: $!";
}
my $next = Path::Iterator::Rule->new->file->iter( $BASE );
while( defined( $_ = $next->() ) ) {
(undef,undef,$_) = File::Spec->splitpath( $_ );
print $_.get($_)."\n";
}
remove_tree( $BASE );
```
I felt bad about using a non-core module, Path::Iterator::Rule, but it wasn't worth reinventing the wheel just to avoid the dependency - it's a great module.
You could adapt this to preserve order by changing what is stored in the file from just the $value to include the $order and $value as well. This is trivial because we only ever add keys to the end of the list.
[Answer]
# perl
I'm sure this can be done a few percent faster in some other language, but perl makes this super quick to implement at the optimal big-O level, and likely performs well enough. This code preserves order.
```
#!/usr/bin/perl -w
use strict;
use warnings;
my $key_size = $ARGV[0] =~ /--key-size=(\d+)/ ?
(shift @ARGV, $1) : 4;
sub slurp {
my $fn = shift;
open my $fh, "<", $fn || die "can't open $fn for reading: $!";
my (%keys, @order);
while(<$fh>) {
chomp;
my $key = substr $_, 0, $key_size;
push @order, $key;
$keys{$key} = substr $_, $key_size;
}
close $fh || die "can't close $fn: $!";
return [ \@order, \%keys ];
}
$_ = slurp shift @ARGV;
my @order = @{ $_->[0] };
my %keys = %{ $_->[1] };
while(@ARGV) {
my ($order2, $keys2) = @{slurp shift @ARGV};
$keys{$_} = delete $keys2->{$_} for (grep { exists $keys2->{$_} } @order);
for (grep { exists $keys2->{$_} } @{$order2}) {
$keys{$_} = $keys2->{$_};
push @order, $_;
}
}
print "$_$keys{$_}\n" for @order;
```
Test output:
```
ski@anito$ perl merger.pl --key-size=4 file1 file2 file3
0010THIS_IS_LINE_1_FROM_FILE2
0011EMPTY_LINE
00A0THIS_IS_LINE_3_FROM_FILE1
0100EMPTY_LINE
```
And here's a slightly faster version that doesn't preserve order:
```
#!/usr/bin/perl -w
use strict;
use warnings;
my $key_size = $ARGV[0] =~ /--key-size=(\d+)/ ?
(shift @ARGV, $1) : 4;
my %keys;
while(@ARGV) {
my $fn = shift;
open my $fh, "<", $fn || die "can't open $fn for reading: $!";
while(<$fh>) {
chomp;
$keys{substr $_, 0, $key_size} = substr $_, $key_size;
}
close $fh || die "can't close $fn: $!";
}
print "$_$keys{$_}\n" for keys %keys;
```
] |
[Question]
[
**Closed**. This question needs to be more [focused](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Update the question so it focuses on one problem only by [editing this post](/posts/22447/edit).
Closed 9 years ago.
[Improve this question](/posts/22447/edit)
Your job is to **write a program to find the closest number to `PI`**.
## Let me clarify.
You will first choose a number type. Let us say you choose `Integer` (in an actual answer, you cannot). Your program would then have to generate an integer that is closed to `PI`. For `Integer`s, this would be `3`. Not `4`; `3`.
For every allowed number type, there will be one and only one closest number, as you will see.
1. Select your number type. It should only be able to represent rational numbers. You can not make up your own number types. `Float` or `Double` is recommended.
2. Your program will generate a number `ctp` for "close to `PI`" (I am just calling it that; you don't have to). `223/71` < `ctp` < `22/7` must be true (this is why you can't choose `Integer`s). Also, `ctp` must be the closet number to `PI` in its number type (although see bonus).
3. No importing libraries for mathematical functions, operations, etc... (although types are allowed as long, as it obeys #1).
4. You must somehow output `ctp`.
5. You also may not hard code any number (in any type) that uses at least half the precision of your chosen number type.
Bonus: If you use a data type with a precision that depends on machine resources, and it still generates the most accurate approximation possible for any given machine, you can take the `pi`th root of your score.
Note: If you code may actually exhaust machine resources, put a warning in. That way people know to use virtual machines to check it (or just check it with their minds).
This is code golf, so shortest program in bytes wins!
**Note: The point of this challenge is not just to be another pi calculation challenge. You have to work at the limits of your number type, where all calculations can have detrimental rounding errors. You are doing maximum-precision computing. This is not the same as just outputting a large number of digits.**
[Answer]
# C++ 158 chars
```
#include<iostream>
#include<iomanip>
int main(){double p=0;for(long long l=1;l>0;l+=2){p+=(double)4/l;l+=2;p-=(double)4/l;}std::cout<<std::setprecision(30)<<p;}
```
Simply calculates pi by brute force until my computer can't store the number to divide 4 by.
I got to 3.1415926535`792384` before I killed it. The highlighted part is what is off; it should have been 3.1415926535`897932`. Eventually, it would have got there.
[Answer]
## Java: 352 chars
```
import java.math.BigDecimal;class B{public static void main(String[]h){BigDecimal y=v(-3);for(int n=1;n<99;n++)y=y.add(v(n).multiply(v(2).pow(n)).multiply(f(n).pow(2)).divide(f(2*n),42,0));System.out.println(y.toPlainString());}static BigDecimal v(int k){return BigDecimal.valueOf(k);}static BigDecimal f(int k){return k<2?v(1):f(k-1).multiply(v(k));}}
```
This is a simplification of [my answer to another question](https://codegolf.stackexchange.com/a/18883/3755). It uses the formula from Simon Plouffe, 1996. It only uses addition, multiplication, division and exponentiation on the JDK's built-in class `java.lang.BigDecimal`.
Idented version:
```
import java.math.BigDecimal;
class B {
public static void main(String[] h) {
BigDecimal y = v(-3);
for (int n = 1; n < 99; n++)
y = y.add(v(n).multiply(v(2).pow(n)).multiply(f(n).pow(2)).divide(f(2 * n), 42, 0));
System.out.println(y.toPlainString());
}
static BigDecimal v(int k) {
return BigDecimal.valueOf(k);
}
static BigDecimal f(int k) {
return k < 2 ? v(1) : f(k - 1).multiply(v(k));
}
}
```
This is the output:
```
3.141592653589793238462643377679212002490611
```
If you change that 99 and that 42, you might adjust the output. The 99 is the number of iterations (more iterations = more precision). The 42 is the number of decimal digits used in the division (so it rounds beyond that in the case of unexact decimal fractions). For example, using 999 and 420 instead, this is the output:
```
3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093844609550582231725359408128481117450284102701938521105559644622948954930381964428810975665933446128475648233786783165271201909145648566923460348610454326648213393607260249120347355734950229986020976256234993050320608823801378401335409091901873689012669359599460964434973644188892882434846280102165
```
Since it is possible to adjust the precision, but only by changing 2 numbers in the source code, but OTOH those numbers have the exact purpose to define the precision, then I don't know if the bonus do applies or do not.
] |
[Question]
[
**Closed**. This question needs to be more [focused](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Update the question so it focuses on one problem only by [editing this post](/posts/21714/edit).
Closed 9 years ago.
[Improve this question](/posts/21714/edit)
Here's a fun idea:
Write a simple game (tic-tac-toe, guess the number, etc) that has an easter egg in it, that can be triggered by a specific, special input from the user and does something cool, but the code for the game does not appear to contain any easter eggs (or any obviously obfuscated code) at first glance.
This is a popularity contest, so highest vote by the community wins.
[Answer]
## TI-BASIC
**Lock Screen** for your TI-84 calculator
```
:Repeat Str1="PASSWORD"
:Input Str1
:End
```
First one to find the egg gets a chicken ;)
] |
[Question]
[
**This question already has answers here**:
[Incrementing Numbers, Over Multiple Sessions](/questions/11056/incrementing-numbers-over-multiple-sessions)
(23 answers)
Closed 10 years ago.
Write a program that after running will show how many times it was ran before. You are only allowed to modify the executable itself (the code itself, or compiled version of your code), you cannot modify anything else or create new files.
Example:
```
$ ./yourprogram
0
$ ./yourprogram
1
$ ./yourprogram
2
```
[Answer]
Somewhat less trivial example than y'old bash, in C:
```
#include <stdio.h>
int main(int argc,char **argv){
const char *data="Da best marker in da world 0\0\0\0\0\0\0";
FILE *f;
int i;
char c;
long int pos;
printf("%s\n",data+27);
f=fopen(argv[0],"r+b");
i=0;
c=fgetc(f);
while(!feof(f)){
if(data[i]==c){
i++;
if(i==27)break;
} else i=0;
c=fgetc(f);
}
if(i!=27)return 1;
i=0;
pos=ftell(f);
c=fgetc(f);
while(c!='\0'){
i=10*i+c-'0';
c=fgetc(f);
}
i++; //The increment!
fseek(f,pos,SEEK_SET);
fprintf(f,"%d",i);
fflush(f);
fclose(f);
return 0;
}
```
] |
[Question]
[
Write a program which takes the current time of the system clock, rounds to the nearest minute (you may choose how to round halves) and displays it formatted as the following:
```
A quarter past one in the morning.
A quarter to two in the afternoon.
Two o'clock in the afternoon.
Twenty-five minutes to three in the morning.
Twenty-seven minutes to seven in the evening.
One minute past twelve in the afternoon.
Twelve o'clock noon.
Twelve o'clock midnight.
```
Rules:
* 12:01am to 11:59am is deemed as morning.
* 12:01pm to 5:59pm is deemed as afternoon.
* 6:00pm to 11:59pm is deemed as evening.
* 15 minutes past the hour must be expressed as `A quarter past` the hour
* 30 minutes past the hour must be expressed as `Half past` the hour
* 45 minutes past the hour must be expressed as `A quarter to` the upcoming hour
* On-the-hour times must be expressed as the hour `o'clock`, with the addition of noon and midnight being expressed with the addition of `noon` or `midnight` respectively.
* Other times in hh:01 to hh:29 must be expressed as (number of minutes) `past` the hour.
* Other times in hh:31 to hh:59 must be expressed as (number of minutes) `to` the upcoming hour.
* Twenty-one to twenty-nine must be hyphenated.
* The first letter of the output must be capitalised. The other letters must be lower-case.
It would be useful to provide a testing version of your code so that it can be tested without manipulating the system clock.
[Answer]
# Mathematica 450
`Date[]` calls for the current date and time. `[[{4,5}]]` returns the hour and minutes
```
f[]:=f[Date[][[{4,5}]]];
f[{h_,m_}]:=Module[{p,w,s},
p@h1_:=Which[0<h<12," in the morning.",12<h<18," in the afternoon.",18<h<24, " in the evening."];
s[t_]:=WolframAlpha["spell "<>ToString@t,{{"Result",1},"Plaintext"}];
w=s[h~Mod~12]<>p@h;
Which[
m==0, Switch[h,12, "noon", 0|24,"midnight",_,s[h~Mod~12]<>p@h],
m==15,"a quarter past "<>w,
m==30,"half past "<>w,
m==45,"a quarter to "<>s[h~Mod~12+1]<>p@h,
m<30,s@m<>" minutes after "<>w,
m>29,s[60-m]<>" minutes before "<>s[h~Mod~12+1]<>p@h]]
```
**Current Time**
```
f[]
```
>
> "ten minutes past three in the afternoon."
>
>
>
**Specific times**
```
f[{4, 45}]
f[{10, 30}]
f[{11, 0}]
f[{12, 0}]
f[{13, 15}]
f[{15, 0}]
f[{22, 17}]
f[{24, 0}]
```
>
> "a quarter to five in the morning."
>
> "half past ten in the morning."
>
> "eleven in the morning."
>
> "noon"
>
> "a quarter past one in the afternoon."
>
> "three in the afternoon."
>
> "seventeen minutes past ten in the evening."
>
> "midnight"
>
>
>
[Answer]
## Python 2.7, ~~159~~ ~~162~~ ~~156~~ 161
```
from datetime import*
n=datetime.now()
if n.hour()<12:
t="morning"
elif n.hour()<18:
t="afternoon"
else:
t="evening"
print"%i in the %s."%(n.hour(),t)
```
**Edit #1** - Added a period at the end of the output.
**Edit #2** - Shortened the imports, lengthened code to correct syntax.
] |
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** [Update the question](/posts/8494/edit) so it's [on-topic](/help/on-topic) for Code Golf Stack Exchange.
Closed 11 years ago.
[Improve this question](/posts/8494/edit)
Given prime factors of a number, what is the fastest way to calculate divisors?
```
clc; clear;
sms=0;
count = 1;
x=0;
for i=11:28123
fac = factor(i);
sm = 1;
for j = 1:length(fac)-1
sm = sm + sum(prod(unique(combntns(fac,j), 'rows'),2));
end
if sm>i
x(count) = i;
count = count + 1;
end
end
sum1=0;
count = 1;
for i=1:length(x)
for j=i:length(x)
smss = x(i) + x(j);
if smss <= 28123
sum1(count) = smss;
count = count + 1;
end
end
end
sum1 = unique(sum1);
disp(28123*28124/2-sum(sum1));
```
currently I'm using this `prod(unique(combntns(fac,j), 'rows'),2)` code which is awfully slow and I'm using Matlab.
[Answer]
# Mathematica
```
Union[Prepend[Times @@@ Rest@Subsets@l, 1]]
```
**Usage**
I'm assuming that repeated factors would be repeated in the list of factors, as below:
```
l = {2, 2, 3, 5, 5, 11, 11, 11, 31, 37, 617};
Union[Prepend[Times @@@ Rest@Subsets@l, 1]]//AbsoluteTiming
```
This routine is much slower than the built in function `Divisors`, which has to first factor the Integer. I am fairly certain that `Divisors` is compiled.
```
Divisors[282584210700]; // AbsoluteTiming
```
>
> {0.000262, Null}
>
>
>
[Answer]
Haskell (with `Data.List`)
```
f :: [Int] -> [Int]
f [] = [1]
f (x:xs) = a ++ map (x*) a
where a=f xs
factorsfromlist1 = nub . sort . f
-- may have better performance
factorsfromlist2 = map head . group . sort . f
```
On the list `[2, 2, 3, 5, 5, 11, 11, 11, 17, 31, 37, 47, 67, 103, 331, 617, 1093, 1597, 2309]`:
```
$ ghc -O test.hs
$ ./test
Prime factors of 2078661171193247994962581628700
Method 1: 1.077712s
Method 2: 0.863675s
```
] |
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
Questions without an **objective primary winning criterion** are off-topic, as they make it impossible to indisputably decide which entry should win.
Closed 4 months ago.
[Improve this question](/posts/265937/edit)
Not sure if it's correct to ask such a question on this site, but let's try.
Let **a(n)** be a sequence of positive integer such that **a(1) = 1**. To reproduce the sequence **a(n)** through itself, use the following rule: if binary **1xyz** is a term then so are **110xyz** and **1XYZ** where the last one is the same as **1xyz** with rewrite **1 -> 10**.
The sequence begins with
**1, 2, 4, 6, 8, 12, 16, 20, 24, 26, 32, 40, 48, 52**
These numbers in binary:
```
[1]
[1, 0]
[1, 0, 0]
[1, 1, 0]
[1, 0, 0, 0]
[1, 1, 0, 0]
[1, 0, 0, 0, 0]
[1, 0, 1, 0, 0]
[1, 1, 0, 0, 0]
[1, 1, 0, 1, 0]
[1, 0, 0, 0, 0, 0]
[1, 0, 1, 0, 0, 0]
[1, 1, 0, 0, 0, 0]
[1, 1, 0, 1, 0, 0]
```
Here are examples:
* **1 -> 10** by the rule **1xyz -> 1XYZ** (rewrite **1 -> 10**)
* **10 -> 100** by the rule **1xyz -> 1XYZ** (rewrite **1 -> 10**)
* **1 -> 110** by the rule **1xyz -> 110xyz**
* **100 -> 1000** by the rule **1xyz -> 1XYZ** (rewrite **1 -> 10**)
* **10 -> 1100** by the rule **1xyz -> 110xyz**
* **1000 -> 10000** by the rule **1xyz -> 1XYZ** (rewrite **1 -> 10**)
* **110 -> 10100** by the rule **1xyz -> 1XYZ** (rewrite **1 -> 10**)
* **100 -> 11000** by the rule **1xyz -> 110xyz**
* **110 -> 11010** by the rule **1xyz -> 110xyz**
* **10000 -> 100000** by the rule **1xyz -> 1XYZ** (rewrite **1 -> 10**)
* **1100 -> 101000** by the rule **1xyz -> 1XYZ** (rewrite **1 -> 10**)
* **1000 -> 110000** by the rule **1xyz -> 110xyz**
* **1100 -> 110100** by the rule **1xyz -> 110xyz**
It appears that positions of the powers of **2** in **a(n)** are partition numbers ([A000041](https://oeis.org/A000041)).
I tried to write an efficient PARI/GP program to generate a list of the first **n** terms and this is what I got:
```
b1(n) = my(L = logint(n, 2), A = n); A -= 2^L; L - if(A==0, 1, logint(A, 2))
upto(n) = my(v1, v2); v1 = vector(n, i, if(i < 3, i)); v2 = [1, 2]; my(k = 2, j = 1, q = 0); for(i = 3, n, my(A = v2[j] + q); if(A >= v2[k-1], k++; v1[i] = 2^(k-1); j=k\2; q = 0; v2 = concat(v2, i), v1[i] = v1[A] + 2^(j-1) + 2^(k - 1); if((k - j - 2) >= b1(v1[A+1]), j++; q = 0, q++))); v1
```
Is there a way to write a simpler program (that is, such a program which returns same number of values faster than my program given above)?
[Answer]
# [Rust](https://www.rust-lang.org/)
Port of @l4m2's c++ answer in Rust.
[Try it online!](https://tio.run/##jVBdj5swEHzPr9i7hxPcQQS5a1SROC@V@tq3qlIUVQ5dUiuOjYyhUVP@eunahEuI@rUSMp4d7@yMqSvbdYWCQuugzEA8zyI4ZlCns7cRyO0ZKXWVwcOhtlBX4jtGwI05Ax8xXzr2KoTTBKhEAY/EhxVzrKlEFQwtVwZtbdTC39vJ8KJ0dLm94tHbtZuzAQbHxSvsRz8xSEcTCm1gD0JBENCQJ0jD6ZSV4dRgMxL3LiGGPZmEH8ROgVfebAjLJfS9MIwcgYS8z3BQaieUU6Vlg8Ff7Eu04Bo@Mp8WGUgW414P9ZjW5dWGLos/h@dqa5DvL4G0Y3MR3HgiJIn6XW8cuSpHWVKaZPHAxUXVraxo3TfJ5yRx39gJp1aD@d06WYDa9L0@Iq/Iz1KjNwJeJb99FRIJWJLGxWVphLJS3QX3pyydtXDKknT@qT0f9xEIcsnXYgOrFcxfQu93/jKAD5Ac39/UwLmyLuCRwWyw/l@6Kk69CJ2/0/bwP9TbrvuZF5Lvqi5@p0sbS2xQsme6SatZwS39WW52aOO8rJniVjRIWK6/4A5VXCthK5bOCRIqN3hAZblk1tTE@vAL)
```
fn foo(p: i32, x: u128, lb: i32, pos: &mut usize, arr: &mut Vec<u128>) {
if *pos >= arr.len() {
return;
}
if p >= lb {
arr[*pos] = x;
*pos += 1;
}
for k in ((lb + 1)..=p).rev() {
foo(p - k, x | ((1 as u128) << (p - k)), k, pos, arr);
}
}
fn solve(arr: &mut Vec<u128>) {
let mut pos: usize = 0;
let mut p = 0;
loop {
if pos >= arr.len() {
break;
}
foo(p, (1 as u128) << p, 0, &mut pos, arr);
p += 1;
}
}
fn main() {
let n = 50_000_00;
let mut a = vec![0; n];
solve(&mut a);
let mut i = 1;
while i < n {
println!("{:12} {:016X}{:016X}", i, (a[i] >> 64) as u64, (a[i] & 0xFFFFFFFFFFFFFFFF) as u64);
i *= 2;
}
println!("{:12} {:016X}{:016X}", n-1, (a[n-1] >> 64) as u64, (a[n-1] & 0xFFFFFFFFFFFFFFFF) as u64);
}
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 52 bytes, 10,000 in ~10s on TIO
```
⊞υ¹ＦＮ«≔⌊υι⟦Ｉι⟧≔⁻υ⟦ι⟧υ≔⍘ι²ι⊞υ⍘⪫⪪ι1¦10²⊞υ⍘⁺110✂ι¹Ｌι¹¦²
```
[Try it online!](https://tio.run/##dY89C8IwEIZn@ytCpwtEaLo6qZOiUuhYOsQS24M0LflwEX97TMCPLt5wB3fP@95dNwjTTUKFUHk7gGeE0012mwyBg569u/jxKg1QSh7Zamst9hrOqHH0I3jKCEZ6VRnUDpq9sA6Qtqn1Q71Nrg22kfaL0U5YWbuo7AEZKb9e7zMW4@OEGupZoUtkznOacpFKSf9oKhX35jxSjNQKO5mknJGT1L0b4pXp0Y/BMwRexAjru3oB "Charcoal – Try It Online") Link is to verbose version of code. Explanation: For each number, generates the two derived numbers, and then takes the minimum number generated for the next number.
```
⊞υ¹
```
Start with `1`.
```
ＦＮ«
```
Generate `n` numbers.
```
≔⌊υι
```
Get the next minimum.
```
⟦Ｉι⟧
```
Write it to the canvas.
```
≔⁻υ⟦ι⟧υ
```
Remove it from the list.
```
≔⍘ι²ι
```
Convert it to binary.
```
⊞υ⍘⪫⪪ι1¦10²
```
Change all `1`s into `10`s, convert from binary, and push the result to the list.
```
⊞υ⍘⁺110✂ι¹Ｌι¹¦²
```
Remove the leading `1`, prefix `110`, convert from binary, and push the result to the list.
] |
[Question]
[
Given an \$n\times m\$ matrix \$A\$ and two integers \$w,h\$, output a matrix of \$w\times h\$ called \$B\$, such that $$B\_{i,j} = \int\_{i-1}^i\mathbb dx\int\_{j-1}^j A\_{\left\lceil \frac xw\cdot n\right\rceil,\left\lceil \frac yh\cdot m\right\rceil}\mathbb dy\text{ (1-index),}$$ $$B\_{i,j} = \int\_i^{i+1}\mathbb dx\int\_j^{j+1} A\_{\left\lfloor \frac xw\cdot n\right\rfloor,\left\lfloor \frac yh\cdot m\right\rfloor}\mathbb dy\text{ (0-index),}$$ or "split a square into \$n\times m\$ smaller rectangles, fill each with the value given in \$A\$, then resplit into \$w\times h\$ one and get average of each small rectangle" (which is a simple image rescaling algorithm and that's why this title is used)
Shortest code in each language wins. You can assume reasonable input range, which may give good to few languages though.
Test cases:
$$ \begin{matrix}1&1&1\\ 1&0&1\\ 1&1&1\end{matrix}, (2,2) \rightarrow \begin{matrix}\frac 89&\frac 89\\ \frac 89&\frac 89\end{matrix}$$
$$ \begin{matrix}1&1&1\\ 1&0&1\\ 1&1&0\end{matrix}, (2,2) \rightarrow \begin{matrix}\frac 89&\frac 89\\ \frac 89&\frac 49\end{matrix}$$
$$ \begin{matrix}1&0\\0&1\end{matrix}, (3,3) \rightarrow \begin{matrix}1&\frac 12&0\\ \frac 12&\frac 12&\frac 12\\ 0&\frac 12&1\end{matrix}$$
$$ \begin{matrix}1&0\\0&1\end{matrix}, (3,2) \rightarrow \begin{matrix}1&\frac 12&0\\ 0&\frac 12&1\end{matrix}$$
[Sample solution just by definition](https://tio.run/##NY0xC8MgFIR3f0r6SmIzO2QpdCkZuskbbJGqRAMimCDvtxsL6XB3391yXiWjvUr2o@okSuEwEJQBOBEL4sZ8UxYjM2Ksc7QhyZd6L/r05yMk/Y0qaTlJyS/3ZV2j3PrcBYR/3XvTeUSEsoG9crDtYAfXyFEbLeRfODCEWOsB)
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~20~~ 14 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
~~I can't help but think that more of the manipulation could be put inside the reduction `ƒ`~~ - done
```
xs€⁴Z¹ƭL¤ZÆmðƒ
```
A full-program accepting `[w, h]` and `A` that prints a representation of `B`.
**[Try it online!](https://tio.run/##AUAAv/9qZWxsef//eHPigqzigbRawrnGrUzCpFrDhm3DsMaS////WzIsNV3/W1sxLCAyLCA0XSwgWzgsIDE2LCAzMl1d "Jelly – Try It Online")**
Or see the [test-suite](https://tio.run/##y0rNyan8/7@i@FHTmkProg7tPLbW59CSqMNtuYc3HJv0//DyR407D608OV0fKO8OxFmPGvcd2nZo2///0dHRRjpGsToK0dGGOkAYqwOkDaA0iB8by6WDX40BVI2xjjFUjQFQxgCu1xiuF0k8FgA "Jelly – Try It Online") (this uses the register `®` in place of the 2nd program argument, `⁴` to make a reusable Link, and formats each result as a grid).
### How?
We repeat row elements `w` times, split these into chunks of length `n` transpose the result, and take the means, then we do the same to the result, but with `h` and `m` instead of `w` and `n`.
```
xs€⁴Z¹ƭL¤ZÆmðƒ - Main Link: [w,h]; A
ðƒ - reduce [A,w,h] by:
x - repeat (row elements) ([[1,2]]x3->[[1,1,1,2,2,2]])
¤ - nilad followed by links as a nilad:
⁴ - 2nd program argument, A
ƭ - call in turn:
Z - ...1st time: transpose
¹ - ...2nd time: do nothing
L - length -> 1st=n; 2nd=m
s€ - split each (row) into chunks of length (n or m)
Z - transpose
Æm - arithmetic mean (vectorises)
- implicit print
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 28 bytes
```
ＦＥ²Ｎ≔ＥιＥζ∕ΣＥμ§μ÷⁺×κＬμπιＬμζＩζ
```
[Try it online!](https://tio.run/##TY9Bi8JADIXv@ytyTCALOrYieCp6KagUdm@lh66OOtgZS2cq0j8/myl7WEhI3vcegZzv7XB@tl2M1@cAeGx7VAyl68dwGu2PHpCIoPDe3NzsGoY0Joa9eZmLxq/RzoZlKELpLvqd1tKFP7/qRo/fxmqPD4aDdrdwR0vE0EsbOU//cVITbT@qwbiAu9YHnIi2MdY5g1RdLxgyhg3DUjWil2sGJUwJVJtEVvLBSmiWklkimaRzobnQ9aJpmvj56n4B "Charcoal – Try It Online") Link is to verbose version of code. Takes input in the order `w`, `h`, `A`. Explanation:
```
ＦＥ²Ｎ
```
Repeat twice, once for the width, once for the height.
```
≔ＥεＥζ∕ΣＥμ§μ÷⁺×κＬμπεＬμζ
```
Rescale and transpose the array.
```
»Ｉζ
```
Output the final array.
] |
[Question]
[
# Introduction
This problem is a challenge that has to do with DOM manipulation at scale and overcoming some issues that may be inherent in dealing with the DOM.
* This challenge is interesting because limitations push us to think through things differently and lean on the strengths of languages different than what we usually use.
* I created this challenge myself based on a real world problem I ran into myself (details can be provided if needed). If this challenge has any relation to a differently know problem, those similarities are coincidental.
This challenge will be scored based on fastest execution.
# Challenge
You must render one of the challenge levels in the Chrome web browser (84.0.4147.89 for standardization purposes) (submissions will need to be JavaScript functions for timing purposes):
* [easy](https://dodzidenudzakuma.com/1000-cells.html)
* [medium](https://dodzidenudzakuma.com/10000-cells.html)
* [hard](https://dodzidenudzakuma.com/100000-cells.html)
Using JavaScript please complete the following:
1. Get each table displayed and add a class `table-n` to each table where `n` is a zero based index of order of the table on the screen. If a table is nested within a table the parent would be N and the child would be N+1 with the next table being N+2.
2. Get each row displayed in each table and add a class of `table-n-row-r` where `r` is a zero based index of rows in the table represented by `table-n`.
3. Get each cell displayed in each table and add a class of `table-n-row-r-cell-c` where `c` is a zero based index of cells in a row represented by `table-n-row-r`.
At the end of the challenge the web page should still be able to be interacted through in the browser, and a call to `document.getElementsByClassName('table-n-row-r-cell-c');` should return one and only one cell from the DOM.
Any method available to you as valid as long as:
1. Access to one of the difficulty levels has been done through Chrome (84.0.4147.89)
2. The URL of the browser and the page displayed doesn't change
3. A call to `document.getElementsByClassName('table-n-row-r-cell-c');` returns only one element
# Output Examples
For this example we're using the [easy](https://dodzidenudzakuma.com/1000-cells.html) level as input.
The abbreviated output in the DOM should be.
```
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Code Golf Challenge</title>
</head>
<body>
<table class="table-0">
<thead>
<tr class="table-0-row-0">
<th class="table-0-row-0-cell-0">1</th>
...
</tr>
</thead>
<tbody>
<tr class="table-0-row-1">
<td class="table-0-row-1-cell-0">11</td>
<td class="table-0-row-1-cell-1">12</td>
...
</tr>
...
</table>
</body>
</html>
```
There are only `<td>` and `<th>` elements used as cell elements for the challenge.
As long as `document.getElementsByClassName('table-n-row-r-cell-c');` returns an element with this class, we're good to go.
# Qualifying Entries
All entries need to have an execution speed of under 40 seconds for at least one difficulty level to qualify.
Timing starts when your algorithm starts, but after the page has loaded completely as all elements must be available (the browser spinner has stopped spinning).
Calculate the runtime for your method by calling `performance.now()` before and and after your injection method, and subtracting the first from the second as in the example below.
```
let t0 = performance.now();
doSomething() // <---- The function you're measuring time for
let t1 = performance.now();
let totalTime = t1 - t0;
```
# Winner
The entry that handles the highest difficulty within 40 seconds wins. Ties are broken by execution time at that difficulty.
[Answer]
# About 200 ms
```
function mark() {
var t = 0, tp = '';
var c = [], i = { r: 0, p: '', c: 0 };
var elements = document.body.getElementsByTagName('*');
var length = elements.length, index, v;
for (index = 0; index < length; ++index) {
v = elements[index];
switch (v.tagName) {
case 'TH':
case 'TD':
v.className = i.p + i.c++;
if (i.c == 10 && i.r == 10) {
i = c.pop();
}
continue;
case 'TR':
v.className = i.p = i.t + i.r++;
i.c = 0;
i.p += '-col-';
continue;
case 'TABLE':
v.className = tp = 'table-' + t++;
tp += '-row-';
c.push(i);
i = { t: tp, r: 0, p: '', c: 0 };
}
}
}
```
If your code runs more than 2s, you must do something wrong. I believe.
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/196516/edit).
Closed 4 years ago.
[Improve this question](/posts/196516/edit)
This challenge is inspired by turn based videogames like "Heroes of Might and Magic"
---
## Implement this game mechanic:
* There is some units(Imps, Swordsmans etc...) in our game
* Every unit have an integer "initiative"
* Your program must decide which unit's turn now - based on unit's initiative
* The more initiative means more frequent turns(for example unit with 10 iniative will move 5 times more often than 2 iniative unit)
* Unit with highest initiative moves first
* Input: Array of pairs of [unit\_name: string, unit\_initiative: integer]
* Output: Unit names in moving sequence separated by line break (\n)
* Make 50 turns total
---
## Test case:
Units:
[["Imp", 500], ["Mammoth", 50], ["Swordsman", 250], ["Elf", 350]]
turn sequence(50 turns) output:
```
Imp
Elf
Imp
Swordsman
Elf
Imp
Imp
Swordsman
Elf
Imp
Elf
Imp
Swordsman
Imp
Elf
Imp
Swordsman
Elf
Imp
Elf
Imp
Swordsman
Mammoth
Imp
Elf
Imp
Swordsman
Elf
Imp
Imp
Swordsman
Elf
Imp
Elf
Imp
Swordsman
Imp
Elf
Imp
Swordsman
Elf
Imp
Elf
Imp
Swordsman
Mammoth
Imp
Elf
Imp
Swordsman
```
## Other rules:
* Use your favorite language
* Write shortest code possible
* Attach a link to an online iterpreter
* Please follow standard code golf rules
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~20~~ 15 bytes
```
P:ṭ×¥Ɱ"Ɗ,€"ẎṢṪ€
```
[Try it online!](https://tio.run/##y0rNyan8/z/A6uHOtYenH1r6aOM6pWNdOo@a1ig93NX3cOeihztXATn/Dy@P/P8/2tTAQMfUQMcIiI1NDWL/Ryt55hYo6Sj5Jubm5pdkAFnB5flFKcW5iXlAtmtOmlIsAA "Jelly – Try It Online")
A dyadic link taking a list of initiative scores as its left argument and a list of characters as its right and returning a list of the characters in movement order.
# [Jelly](https://github.com/DennisMitchell/jelly), 14 bytes
```
İṭ×¥Ɱ"$,€"ẎṢṪ€
```
[Try it online!](https://tio.run/##y0rNyan8///Ihoc71x6efmjpo43rlFR0HjWtUXq4q@/hzkUPd64Ccv4fXh75/3@0qYGBjqmBjhEQG5saxP6PVvLMLVDSUfJNzM3NL8kAsoLL84tSinMT84Bs15w0pVgA "Jelly – Try It Online")
This version is one bytes shorter but I expect may sometimes get the order wrong because of inaccuracies in floating point calculations.
] |
[Question]
[
## This page is not for [Visual Basic .NET Tips](https://codegolf.stackexchange.com/q/155840/61846 "Visual Basic .Net Tips") or [VBA tips](https://codegolf.stackexchange.com/q/5175/61846 "Visual Basic for Applications Tips")
Visual Basic (VB or VB6) is an object-oriented and event-driven dialect of [basic](/questions/tagged/basic "show questions tagged 'basic'") that was developed and released by Microsoft in 1991. The last release of Visual Basic came as Visual Basic 6.0 in 1998, and the language was declared a legacy language in 2008. Visual Basic .NET replaced Visual Basic in 2002.
All answers on this site that are written in Visual Basic are assumed to be written for Visual Basic 6.0 unless otherwise stated.
>
> Some helpful links
>
>
> * [MSDN Visual Basic 6.0 Resource Center](https://msdn.microsoft.com/en-us/library/windows/desktop/ms788229.aspx?f=255&MSPPError=-2147217396 "Visual Basic 6.0 Resource Center - MSDN")
> * [Visual Basic Wiki](https://en.wikipedia.org/wiki/Visual_Basic "Visual Basic - Wikipedia")
>
>
>
You may compile and execute Visual Basic code using Visual Studio Community.
There is no online resource for compiling VB code.
[Answer]
# Use `DefXXX` statements when declaring multiple variables
The statement
```
DefDbl A-D
```
Defines all variables that start with `A` through `D` as being of the type `Double`, which means this can shorten cases such as
```
Dim A As Double
Dim B As Double
Dim C As Double
Dim D As Double
```
Similar commands exist for the following types
```
DefBool '' Boolean
DefByte '' byte
DefCur '' Currency
DefDate '' Date
DefDbl '' Double
DefDec '' Decimal
DefInt '' Integer
DefLng '' Long
DefObj '' Object
DefSng '' Single
DefStr '' String
DefVar '' Variant
```
[Answer]
# Use `Console.Write` over `Console.WriteLine`
There is quite a large amount of overhead code necessary to get a snippet of code to execute in VB, and by default this overhead is configured to take up quite a large amount of bytes - for instance
```
Module M
Sub Main
Console.WriteLine("Hello, World!")
End Sub
End Module
```
May be golfed down by 4 bytes by the `Console.Write(...)` command over `Console.WriteLine(...)`.
```
Module M
Sub Main
Console.Write("Hello, World!")
End Sub
End Module
```
] |
[Question]
[
**This question already has answers here**:
[Sierpinski Carpets](/questions/40104/sierpinski-carpets)
(30 answers)
Closed 6 years ago.
A menger sponge is a fractal made out of cubes within cubes within cubes...
If you start with a cube, on each face there are 9 squares. The middle square becomes empty (or 0). The other 8 squares iterate this process. They each get split up into 9 squares and the middle square face is taken out.
The goal today is to generate a menger sponge *face*, not the cube.
Here are some example given an input for the number of iterations.
```
0:
1
(No holes or anything, solid face)
1:
1 1 1
1 0 1
1 1 1
2:
111111111
101101101
111111111
111000111
101000101
111000111
111111111
101101101
111111111
```
To complete the challenge, based on an input, return a set of 1 (filled in blocks) and 0 (empty blocks) with spaces between or not.
This is code golf, lowest number of bytes wins.
[Answer]
# [SOGL V0.12](https://github.com/dzaima/SOGL), 19 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md)
```
1¹.{³³┼┼≥:10ŗ;┼┼⁴++
```
[Try it Here!](https://dzaima.github.io/SOGLOnline/?code=MSVCOS4lN0IlQjMlQjMldTI1M0MldTI1M0MldTIyNjUlM0ExMCV1MDE1NyUzQiV1MjUzQyV1MjUzQyV1MjA3NCsr,inputs=Mw__)
```
1¹ push [1]
.{ input times do
³³ duplicate top of stack 4 times, resulting in 5 total copies in the stack
┼┼ join the last 3 copies horizontally together
≥ put the joined at the bottom of the stack
: duplicate top of stack again
10ŗ replace 1 with 0 only in the top item
; swap the top 2 items
┼┼ join the top 3 items horizontally together
⁴ copy the item one below top of stack
++ add together vertically
```
] |
[Question]
[
**This question already has answers here**:
[Distance to four](/questions/92882/distance-to-four)
(6 answers)
Closed 6 years ago.
## Background
The Collatz Conjecture is quite well-known. Take any natural number. Triple and increment if odd; cut in half if even. Repeat, and it will reach 1 eventually. This famous conjecture, however, is only that, for it is yet unproven.
Little-known to the world, that was not Lothar Collatz's first attempt at fame. His first Conjecture (now proven) was a touch simpler:
* Take any natural number *n*.
* While *n* ≠ 4, find the length of its written-out form (English). Store this value to *n*.
The conjecture is that all natural numbers will eventually become 4. This did not catch on as well as Collatz had hoped, so he returned to the drawing board.
## Your task
Read a positive integer *n* < 2147483648 (2^31) from input and return/print the number of iterations required to reach 4.
## Things to note
Do not use *and*. 228 is "two hundred twenty-eight," **not** "two hundred and twenty-eight."
Do not use articles. 145 is "one hundred forty-five," not "a hundred forty-five.)
Commas set apart each three orders or magnitude: "one million, four hundred eighty-two thousand, one hundred seventy-five."
Punctuation is counted. Spaces are not. Hyphenate 21-99 except multiples of ten.
## Test cases
>
> 4 (four): **0**
>
> 3 (three→five→four): **2**
>
> 6278 (six thousand, two hundred seventy-eight→thirty-five→eleven→six→three→five→four): **6**
>
> 1915580 (one million, nine hundred fifteen thousand, five hundred eighty→fifty-five→ten→three→five→four): **5**
>
> 2147483647 (two billion, one hundred forty-seven million, four hundred eighty-three thousand, six hundred forty-seven→ninety-three→twelve→six→three→five→four): **6**
>
>
>
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest code (in bytes) in each language WINS! Good luck!
[Answer]
# [Python 3](https://docs.python.org/3/) + [inflect](https://pypi.python.org/pypi/inflect), ~~122~~ 114 bytes
Saved 8 bytes thanks to [Scrooble](https://codegolf.stackexchange.com/users/73884/scrooble).
```
from inflect import*
f=lambda k,i=0:k!=4and f(len(engine().number_to_words(k,andword="").replace(" ","")),i+1)or i
```
This cannot be tested online because of the package it uses. Running the test suite gives:
```
4 -> 0
3 -> 2
6278 -> 6
1915580 -> 5
```
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/140373/edit).
Closed 6 years ago.
[Improve this question](/posts/140373/edit)
Write the minimal code you need to take a screenshot of your application window. I am not asking for a function or program; just only a code segment.
It has obviously to be a GUI application; console applications not allowed.
**Input:**
None.
**Output:**
The valid outputs are:
* Clipboard. Then post a screenshot of the Paste contents on a drawing program.
* A file. Upload it somewhere and post a link to it here.
* Inside any other window different from the window that was shoot. Post screenshot of the new window here.
As it is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") minimum number of characters wins!
[Answer]
# Java 8, ~~82~~ ~~80~~ 77 bytes
Class that extends `Frame`:
```
ImageIO.write(new Robot().createScreenCapture(bounds()),"png",new File("a"));
```
Regular Class **98 Bytes**:
```
ImageIO.write(new Robot().createScreenCapture(Frame.getFrames()[0].bounds()),"png",new File("a"));
```
Uses deprecated `bounds()` method.
[](https://i.stack.imgur.com/2rCVl.png)
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/139453/edit).
Closed 6 years ago.
[Improve this question](/posts/139453/edit)
Make a program/function which takes in an integer from 0 to 999999999999 (inclusive) as input and returns how many syllables it has when spoken in English. Make your code short.
**Specification**
* A billion is a thousand million, a trillion is a million million, etc.
* A million has three syllables -- it's mill-ee-on, as opposed to mill-yon. Pronounce all -illions like this.
* Numbers like 1115 are 'one thousand, one hundred *and* fifteen'. The 'and' counts as a syllable.
* 0 is zero. That's two syllables.
I know the specification seems mishmash in terms of which standards are used (British or American, mainly) -- it's what I and everyone I know use. I would change it so it's consistent, but someone's already answered...
**Test Cases**
```
> 0
2
(zero)
> 100
3
(one hundred)
> 1000001
6
(one million and one)
> 1001000001
10
(one billon, one million and one)
> 7
2
(seven)
> 28
3
(twenty-eight)
> 78
4
(seventy-eight)
> 11
3
(eleven)
> 1111
10
(one thousand, one hundred and eleven)
> 999999999999
36
(nine hundred and ninety-nine billion, nine hundred and ninety-nine million, nine hundred and ninety-nine thousand, nine hundred and ninety-nine)
```
[Answer]
# [Python 2](https://docs.python.org/2/), 232 bytes
```
def f(a):o=map(int,format(a,",").split(","));print(a%100>0)*(a>1000)+sum((k%100>0)*(k/100>0)for k in o[:-1])+sum((k>99)*2+`k`.count('7')+(k/10%10>0)+3-`k+1000`.count('0')for k in o)+sum((0<o[~k])*(5-k)*k/2for k in range(len(o)))or 2
```
[Try it online!](https://tio.run/##TY3RboMwDEXf@xVRpQmbhDbJNHWwlR9BSEQtdJCSIEof9tJfZw7bUC3FvvK9Phm@py/v9Dyf64Y1YDDzx94M0LpJNH7szQRGbMUWd7fh2k4QJH4MI/lgXpSUucQYTE5KIr/dewC7ru3@VxGIWdY65ossUeV/Lk9TjDWvbLU7@TsBo0OEfLkiBN3x16SyPKDXhIyeaH8g@emLhy3pw7fEYmz3eo2Mxl1quNYOPCLSVs/B64JXSMGIvTQqtYhVHwTT7zToqWCp0NOnKrMNo2qgw/kH)
This still has some potential for golfing, maybe in a lambda.
The function splits the input into groups of three digits, each of which have a certain number of syllables. Luckily, every digit is 1 syllable except for 7. Every tens-place adds an extra 1 syllable to the number of syllables of the digit except for 1, which adds 0 (`-teen` or `ten`).
Ungolfed:
```
def f(k):
a=k
if a==0:return 2
o=[]
while a>0:
o.append(a%1000)
a/=1000
o=o[::-1]
return \
int(o[-1]%100>0 and len(o)>1) +len('+1 if first group of three have "and"'[0:0])+\
sum(\
[int(k%100>0 and k/100>0) +len('+1 if rest have "and"'[0:0])\
for k in o[:-1]])+
sum(\
[int(k>99)*2 +len('have "hundred"'[0:0])\
+str(k).count('7') +len('+1 for "se-ven"'[0:0])\
+(k/10%10>0) +len('+1 for "-ty" e.g. nine-ty'[0:0])\
+3-str(k+1000).count('0') +len('+1 for each number'[0:0])\
for k in o])+\
sum(\
[int(o[-(k+1)]>0)*([0,2,3,3][k]) +len('add 2 if "thousand", add 3 if "million", add 3 if "billion"'[0:0])\
for k in range(len(o))])
```
*-12 bytes thanks to @Mr.Xcoder*
] |
[Question]
[
**This question already has answers here**:
[Golfing Relay Race](/questions/12071/golfing-relay-race)
(2 answers)
Closed 6 years ago.
# Task
You must write a program in Language A that will output the source code for a program in Language B which will then output the source code for a program in Language C and so on and so forth. The final program must output the `x root y` where `x` and `y` are the inputs e.g. in Python:
```
print(int(input()) ** (1/int(input())))
```
Your score is `L / N` where `L` is the total length of all your programs and `N` is the number of languages.
`N` must be greater or equal to 3 to allow for a proper challenge.
Different versions don't count as different languages
As usual, lowest score wins.
# Example submission
```
# C++/brainfuck/Python, 223 points
## C++
#include <iostream>
int main() {
printf("+[------->++<]>++.++.---------.+++++.++++++.+[--->+<]>+.-----[->+++<]>.+++++.++++++.+[--->+<]>+.-----[->+++<]>.+++++.++.+++++.-.+[--->+<]>+.+..---------.++++++++++..----------.++++++++.+++++++++.--.[--->+<]>++++.+++++.++++++.+[--->+<]>+.-----[->+++<]>.+++++.++.+++++.-.+[--->+<]>+.+....");
}
## brainfuck
+[------->++<]>++.++.---------.+++++.++++++.+[--->+<]>+.-----[->+++<]>.+++++.++++++.+[--->+<]>+.-----[->+++<]>.+++++.++.+++++.-.+[--->+<]>+.+..---------.++++++++++..----------.++++++++.+++++++++.--.[--->+<]>++++.+++++.++++++.+[--->+<]>+.-----[->+++<]>.+++++.++.+++++.-.+[--->+<]>+.+....
## Python
print(int(input()) ** (1/int(input())))
```
[Answer]
# 05AB1E/GolfScript/Jelly ~~11~~ 6 bytes / 3 languages = 2
```
"'İ*@'
```
Both 05AB1E and GolfScript have the nice property that they do implicit prints of strings, so we only lose 3 bytes on them (because 05AB1E doesn't need the closing quote).
Also, my first 05AB1E, GolfScript, and Jelly programs.
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/112663/edit).
Closed 6 years ago.
[Improve this question](/posts/112663/edit)
Randomly choose one out of `k`-length, ordered subset of characters in a string, while only storing a limited number of characters. The subset must be chosen with equal probability and may contain repeated characters. Do this without generating all possible permutations and assume k is at most the length of the string. For example, the string `daddy` has 7 subsets of length two: `da`, `dd`, `dy`, `ad`, `ay`, `yd`, `ya`. The function should return any one of them with the probability of `1/7`.
[Answer]
# Pyth - 5 bytes
While we're arguing about the nomenclature, I'm just guessing at the rules based on the example to just mean pick one from all unique permutations of length `n` of the string.
```
O{.PF
```
[Try it online here](http://pyth.herokuapp.com/?code=O%7B.PF&input=%22tree%22%2C+2&debug=0).
[Answer]
# [Perl 6](https://perl6.org), ~~75~~ 71 bytes
```
{set(flat $^a.comb.combinations($^b).map: *.permutations.map: *.join).pick}
```
[Try it](https://tio.run/nexus/perl6#NVBBbsIwELznFSuUNgkEk/bQQwO06gN6aNUbQjJmoW4SJ4o3CBSFx7Tv6Jt64kxtQyRrV5qdGc9uoxF2D0ykXnGAW1GuEWbnViOFm5wT@EvORFmsXJGKkyyVDv3lKmIFrx5hyCqsi4Yugx77KqWKWCVF1p2N7TOhJg0zyKVCHV6lrQegcE/QqBy1hmJiAIDg7/c7gKPtPwH4UzKUudGy4ZOb992fZhYOF@tRZIBJasrxSo9Hdup1njChiCuCt4/Xd8O@S5Ik9TZl3Wcaz42D1cSwyCKXyQauUTe5ixy6k1wYhrDfOyv7WdUQ2EUhiO3rNeyFb1nFZX29Rgshy/AAszkMWrbjeYMwtEFg4qy6m0HEtlITdF53NstTjWh2j@H@pMqx4OIT/wE "Perl 6 – TIO Nexus")
```
{set($^a.comb.combinations($^b).map: |*.permutations.map: *.join).pick}
```
[Try it](https://tio.run/nexus/perl6#NVDLTsMwELznK1ZVIY@mbuHAgTYB8QEcQNwqJNddikniRLFTpQrpx8B38E2cOJe1m0rWrjQ7M57dRiPsbphYeMUeLkW5QUiOnUYTjF85E2WxdkUqbmSpNKHrkBW8uoXPiFVYF405TU5gxD5KqUJWSZH1R7K8N6iNhgRyqVAHg7bzABS2BhqVo9ZQzAgA8H9/vnw42P7tw3hpiJKSlkV3bn7u42Vm4WC1mYQEzBZUDgM9ntip13uCQhmuDDy9PD4T@2o@ny@8t7I@Z5qm5GA1Mayy0GWygWvUTe4iB@4cJwYR2tZZ2c@qxoBdFPzYvrOGPfAtq7ish2t0ELAM95CkMOrYjucNQmSDwMxZ9RejkG2lNtB7/ZGWNzUi7R7D9Z8qp4KLd/wH "Perl 6 – TIO Nexus")
## Expanded:
```
{
set( # get the unique values from: (equal probability)
$^a.comb.combinations($^b) # get the combinations
.map: |*.permutations # get the permutations of the combinations
.map: *.join # join each permutation into a string
).pick # pick one
}
```
---
The following could almost work except that it has a different probability if there are any repeats of characters.
```
{$^a.comb.pick($^b).join}
```
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/103005/edit).
Closed 7 years ago.
[Improve this question](/posts/103005/edit)
Create a script that, when run from a console, will display the text already in the console, prior to running.
# Challenge
* How will the winner of the challenge will be determined?
>
> The golf with the shortest length (in bytes) will win.
>
>
>
# Example Input and Output
Input:
(Shown is Windows)
```
Microsoft Windows [Version 10.0.14393]
(c) 2016 Microsoft Corporation. All rights reserved.
C:\Users\CSS>dir
Volume in drive C has no label.
Volume Serial Number is B0A1-E768
Directory of C:\Users\CSS
11/30/2016 07:18 PM <DIR> .
11/30/2016 07:18 PM <DIR> ..
12/01/2016 04:45 PM <DIR> .android
10/25/2016 12:41 PM <DIR> .atom
11/29/2016 05:52 PM <DIR> .dnx
10/27/2016 09:34 PM 148 .gitconfig
11/28/2016 03:02 PM <DIR> .MemuHyperv
11/29/2016 05:55 PM <DIR> .nuget
12/01/2016 04:42 PM <DIR> .oracle_jre_usage
10/26/2016 11:37 PM <DIR> .ssh
12/04/2016 06:20 PM <DIR> .VirtualBox
11/29/2016 12:56 PM <DIR> .vscode
11/28/2016 03:53 PM 8,528 2016-11-28-20-44-28.000-VBoxSVC.exe-2608.log
11/28/2016 05:09 PM <DIR> Andy
11/23/2016 10:01 AM <DIR> Contacts
12/11/2016 11:16 PM <DIR> Desktop
11/30/2016 07:35 PM <DIR> Documents
12/11/2016 01:43 AM <DIR> Downloads
11/23/2016 10:01 AM <DIR> Favorites
11/22/2016 07:23 PM 409 fciv.err
11/22/2016 07:21 PM 266 hi
11/23/2016 10:01 AM <DIR> Links
11/22/2016 04:28 PM 15 me.txt
11/28/2016 03:08 PM <DIR> Music
10/25/2016 12:44 AM <DIR> OneDrive
12/09/2016 05:57 PM <DIR> Pictures
11/23/2016 10:01 AM <DIR> Saved Games
11/24/2016 08:56 PM 151 search.bat
11/23/2016 10:01 AM <DIR> Searches
11/07/2016 11:00 AM 11 t.bat
11/24/2016 08:55 PM 93 update.bat
11/28/2016 03:08 PM <DIR> Videos
8 File(s) 9,621 bytes
24 Dir(s) 152,887,300,096 bytes free
C:\Users\CSS>
```
---
Output:
**The script must display something like the text above, in the sense that it must display exactly what was in the console before the script was called.**
[Answer]
# MacOS terminal, 84 bytes
```
osascript -e 'tell app "System Events" to keystroke "ac" using command down'
pbpaste
```
Simple select-all then copy-and-paste.
] |
[Question]
[
In a project I am working on, I am checking to see if certain DNA sequences appear in certain genes in E. coli. I have written a program in Java that performs the below features. However, since I wrote my program in [Java](http://meta.codegolf.stackexchange.com/a/5829/43444), the universe needs to be corrected and rid of verbosity by having you write your code in as few bytes as possible.
My program took a DNA sequences and a regex as input (for this challenge, order doesn't matter). The DNA sequence contains only the letters `A`, `C`, `G`, and `T`. It will be determined if the DNA sequence contains any subsequences that follow the regex, and the output of the program will be the one-indexed location(s) of the first character of each matching subsequence in the DNA sequence in your choice of format. If there is no such location, you may output any reasonable indicator of this.
The regex I used had the following specifications.
* `A`, `C`, `G`, and `T` match to themselves.
* `N` matches to any of `A`, `C`, `G`, and `T`
* `(X/Y)` means that at the current location in the sequence, the next character(s) in the sequence match `X` or `Y` (note that `X` and `Y` can be multiple characters long, and that there can be multiple slashes; for example, `(AA/AG/GA)` matches to `AA`, `AG` or `GG`; however, `X` and `Y` must have the same length)
You may assume that the DNA sequence is longer than any sequence that follows the specifications of the regex, and that both the DNA and the regex are valid.
---
## Test cases
Here, the DNA sequence is first, and the regex is second.
```
AAAAAAAAAA
AAA
==> 1 2 3 4 5 6 7 8
ACGTAATGAA
A(A/C)(T/G/A)
==> 1 5
GGGGCAGCAGCTGACTA
C(NA/AN)
==> 5 8 15
ACGTTAGTTAGCGTGATCGTG
CGTNA
==> 2 12
```
---
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"). The shortest answer in bytes wins. Standard rules apply.
[Answer]
# Python 3, 125 bytes
```
import re,sys
a=sys.argv
s=re.sub
print([i+1 for i in range(len(a[1]))if re.match(s('N','[ACGT]',s('/','|',a[2])),a[1][i:])])
```
[Answer]
# Pyth, 28 bytes
```
fT*VSlQ_:RX+\^z"/N.|")0_M.__
```
Simple regex matching.
I hope there had a function which returns the position of each match, but there is not.
[Test suite.](http://pyth.herokuapp.com/?code=fT%2aVSlQ_%3ARX%2B%5C%5Ez%22%2FN.%7C%22%290_M.__&test_suite=1&test_suite_input=%22AAAAAAAAAA%22%0AAAA%0A%22ACGTAATGAA%22%0AA%28A%2FC%29%28T%2FG%2FA%29%0A%22GGGGCAGCAGCTGACTA%22%0AC%28NA%2FAN%29%0A%22ACGTTAGTTAGCGTGATCGTG%22%0ACGTNA&debug=0&input_size=2)
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/77254/edit).
Closed 7 years ago.
[Improve this question](/posts/77254/edit)
What you need to do is create a Boolean parser.
---
Boolean expressions, in case you haven't heard of them yet, have two inputs and one output. There are four 'gates' in boolean arithmetic, namely OR (represented by `|`), AND (represented by `&`), NOT (which are used a bit like brackets : `/` and `\` ***note, I could have used `!`, but you can't use them as brackets, since `!!!!` is ambiguous (`//\\` or `/\/\`)***) and XOR (represented by `^`). These gates operate on their inputs which are either true or false. We can list the possible inputs (A and B in this case) and the outputs (O) using a **truth table as follows:**
```
XOR
A|B|O
-----
0|0|0
0|1|1
1|0|1
1|1|0
OR
A|B|O
-----
0|0|0
0|1|1
1|0|1
1|1|1
AND
A|B|O
-----
0|0|0
0|1|0
1|0|0
1|1|1
```
NOT is only 1 input, and it goes from true to false and vice versa.
In Boolean expressions, they are used like this:
```
1^((0&1&1)&/(1&0&1)\)
```
Evaluating as follows:
```
1^(( 1 |1)&/(1&0&1)\) | 0 OR 1 = 1, order of operations left to right - no brackets
1^(( 1 )&/(1&0&1)\) | 1 OR 1 = 1
1^( 1 &/(1&0&1)\) | Remove brackets
1^( 1 &/( 0 &1)\) | 1 AND 0 = 0
1^( 1 &/( 0 )\) | 0 AND 1 = 0
1^( 1 &/ 0 \) | Remove brackets
1^( 1 & 1 ) | NOT 0 = 1
1^( 1 ) | 1 AND 1 = 1
1^ 1 | Remove brackets
0 | 1 XOR 1 = 0
```
so 0 is the result.
**Task: create a program to do this!\***
## I/O examples
```
Input -> Output
1v(0.1) -> 1
1v(0.1./1\) -> 1
/0\v(0+1) -> 0
0v1v1 -> 0
```
## Notes
* There is no order of precedence. We will treat `0.1v0+1` as `(((0.1)v0)+1)`
### Leaderboard
```
var QUESTION_ID=77254,OVERRIDE_USER=42854;function answersUrl(e){return"http://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"http://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
```
```
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
```
```
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>
```
[Answer]
# GNU Sed 4.2.2, 102
Score includes +1 for `-r` option to `sed`:
```
y/+./oa/
:
s%/0\\%1%
s%/1\\|\b(0o0|(\w)v\2)%0%
s%\b(\wo\w|\wv\w|1a1)%1%
s/\b\wa\w/0/
s/\((\w)\)/\1/
t
```
[Ideone.](https://ideone.com/8aJM7h)
---
[Incomplete Retina port.](http://retina.tryitonline.net/#code=VGArLmByYQooYC8wXFwKMQovMVxcfFxiKDByMHwoXHcpdlwyKQowClxiKFx3clx3fFx3dlx3fDFhMSkKMQpcYlx3YVx3CjAKXCgoXHcpXCkKJDE&input=MXYoMC4xKQoxdigwLjEuLzFcKQovMFx2KDArMSkKMHYxdjEKMXYoKDArMSkuLygxLjApXCkKMC4xdjArMQ)
] |
[Question]
[
**This question already has answers here**:
[Convert number to a base where its representation has most "4"s](/questions/10608/convert-number-to-a-base-where-its-representation-has-most-4s)
(20 answers)
Closed 8 years ago.
# Challenge
Inspired by [this](http://www.smbc-comics.com/index.php?db=comics&id=2874) SMBC comic, discussed on [reddit](https://www.reddit.com/r/math/comments/17oyhn/smbc_fourier/), [math.stackexchange](https://math.stackexchange.com/questions/312640/how-to-solve-for-the-fouriest-number), and [calculus7](http://calculus7.org/2013/02/09/fourier-transform-according-to-saturday-morning-breakfast-cereal/), the challenge is to return the lowest base such that a number is "fouriest."
# Description
>
> [From the comic]
>
>
> "It's called a Fourier Transform when you take a number and convert it to the base system where it has more fours, thus making it 'fourier.' If you pick the base with the most fours, the number is said to be 'fouriest.'"
>
>
>
The challenge is: given an integer greater than four, return the lowest base in which it is "fouriest."
# Rules
* The solution may be either a function or a full program, whose input and output are of integral type (Int, Long, etc.)
* If your language has a function to convert base systems or solve this challenge for a number other than four, it is disallowed
* I will not accept my own solution
* Solution with the lowest number of bytes wins!
# Test Cases
```
f(17) = 13
f(72) = 17
f(176) = 43
f(708) = 176
f(500) = 124
f(2004) = 500
f(1004) = 250
f(4020) = 1004
f(1004) = 250
f(4020) = 1004
f(4076) = 1018
f(16308) = 4076
f(8156) = 2038
f(32628) = 8156
f(3444443) = 10
f(9440449) = 5
```
Aside: Except for the final two test cases (which are palindromic primes), each one is a record in this sequence such that its position is an additional record.
You may also note that (the position)/(the record) is around four, and I conjecture that this ratio converges to four.
# Test Implementations:
Mathematica:
```
Maxnum4s[x_] := Block[{thisbest = 0, best = 0, bestpos = 4},
Do[thisbest = num4s[x, pos];
If[thisbest > best, best = thisbest; bestpos = pos, 0], {pos, 5, x - 1}]; {bestpos, best}]
```
Python3:
```
def foursCount(x0,b):
count = 0
x = x0
while x > 0:
if x % b == 4:
count += 1
x = x // b
return count
def fouriest(x):
bestpos = 4
best = 0
this = 0
for pos in range(4,x):
this = foursCount(x,pos)
if this > best:
best = this
bestpos = pos
return bestpos
```
C:
```
int foursCount(int x0, int b){
int count = 0;
int x = x0;
while (x > 0) {
if (x % b == 4) {
count++;
}
x = x / b;
}return count;
}
int fouriest(int x){
int pos = 5;
int this = 0;
int best = 0;
int bestpos = 0;
while (pos < x) {
this = foursCount(x, pos);
if (this > best) {
bestpos = pos;
best = this;
}
pos++;
}
return bestpos;
}
```
If you're curious, just for fun:
```
Mathematica: 77.042 s
Python: 8.596 s
Haskell (Interpreted): 579.270 s
Haskell (compiled): 4.223 s
C: 0.129 s
```
[Answer]
# Haskell, 82 bytes
The function 'f' gives the final result:
```
_#0=0
b#x=sum[1|4==mod x b]+b#div x b
f x=[b|b<-[5..x],and[b#x>=c#x|c<-[b..x]]]!!0
```
Less golfed:
```
countFours 0 _ = 0
countFours base x | x == 0 = 0
| mod x base == 4 = 1 + countFours (div x base) base
f x = head [base | base <- [5..x], and smallerBasesNotFouriest]
where
smallerBasesNotFouriest = [(countFours base x) >= (countFours base' x) | base' <- [5..base]]
```
] |
[Question]
[
## Objective
Write a program in any language that reads a matrix from `stdin` in which all columns are space delimited and all rows are newline delimited. The program must output a sub matrix so as that there is no other sub matrix with greater average, this sub matrix' average value, as well as the starting and ending coordinates. Each sub matrix must be at least 2x2. The initial matrix can be an m *x* n matrix where 2 < m < 256 and 2 < n < 512. For each element e, you know that -1000000 < e < 1000000
## Example Inputs
A)
```
1 2 3 4 5 6
7 8 9 10 11 12
13 14 15 16 17 18
```
B)
```
1 1 1
1 1 1
1 1 1
```
## Example Output
A)
```
Sub Matrix:
11 12
17 18
Average of all values:
14.5
Starting Coordinates:
[4,0]
Ending Coordinates:
[5,1]
```
B)
```
Sub Matrix:
1 1
1 1
Average of all values:
1
Starting Coordinates:
[0,0]
Ending Coordinates:
[1,1]
```
## Rules
You may not use any matrix related library provided for your language but you may use lists, arrays, tables, dictionaries and all the operations that can be performed without including / importing anything in your language.
## Scoring
1. You get one point for every additional byte of code.
2. You get one point for every variable you use (even if it's a list).
3. You get one point for every function / method (including lambda / anonymous) you use.
4. The winner is the solution with the fewest points.
[Answer]
# MATLAB, 332 + 9 + 7 = 348
The code:
```
v=str2num(input(''));s=size(v);d=[];e={};for m=1:s(1)-1 for n=1:s(2)-1 for o=1:s(1)-m for p=1:s(2)-n q=v(o:m+o,p:n+p);e=[e {q}];d=[d;mean(q(:)) o p o+m p+n];end;end;end;end;[~,m]=max(d(:,1));disp('Sub Matrix:');disp(e{m});fprintf('Average of all values:\n%f\nStarting Coordinates:\n[%d,%d]\nEnding Coordinates:\n[%d,%d]\n',d(m,1:5))
```
And an explanation
```
%Functions used (7):
% input str2num size mean max disp fprintf
%Variables used (9):
% v s d e m n o p q
v=str2num(input('')); %Convert to matrix (new lines and spaces are correctly handled by str2num to form dimensions)
s=size(v); %Dimensions of n.
d=[];
e={};
for m=1:s(1)-1
%Loop through all widths from 2 up to the width of the matrix (-1 to save doing that later)
for n=1:s(2)-1
%Loop through all heights from 2 up the the width of the matrix (-1 to save doing that later)
for o=1:s(1)-m
for p=1:s(2)-n
%Extract the sub array
q=v(o:m+o,p:n+p);
%Store the sub array in a cell array so we don't have to extract it later.
e=[e {q}];
%Append to the list the details (mean and indicies) of this sub array.
d=[d;mean(q(:)) o p o+m p+n];
end
end
end
end
%Find the index of the sub array with the largest mean
[~,m]=max(d(:,1));
%And print the output
disp('Sub Matrix:');
disp(e{m});
fprintf('Average of all values:\n%f\nStarting Coordinates:\n[%d,%d]\nEnding Coordinates:\n[%d,%d]\n',d(m,1:5))
```
`input` asks for you to enter the matrix. Because MATLAB struggles with new lines, you need to type something like `['1 2 3 4' 10 '5 6 7 8']` Note that the 10 is the new line character. This basically just forms the array exactly as your string would be (the `'` and `[]` are not passed in to the code)
[Answer]
# Matlab, 386 = 366 + 12 + 8
I assumed that we have to make outputs exactly formatted like the output example.
Variables:
```
a,N,r,c,M,i,j,k,l,P,p,n
```
Functions:
```
input,char,str2num,numel,reshape,mean,disp,sprintf
```
Code (added newlines and indenteation for readability):
```
a=input('');
N=char(10);
r=sum(a==N);
a(a==N)=32;
a=str2num(a);
c=numel(a)/r;
a=reshape(a,r,c);
M=-inf;
for i=1:r-1;
for j=1:c-1;
for k=i+1:r;
for l=j+1:c;
P=a(i:k,j:l);
p=mean(P(:));
if p>M(1);
M=[p,i,j,k,l];
n=P;
end;
end;
end;
end;
end;
disp('Sub Matrix:');
disp(n);c='ing Coordinates:\n[%d,%d]\n';
disp(sprintf(['Average of all values\n%d\nStart',c,'End',c],M(1),M(2),M(3),M(4),M(5)))
```
] |
[Question]
[
Given an input, calculate the correct suffix and output the number in a readable format in short scale (where 1 billion is 10^9). The suffixes must go to at least 10^3000, in which the rules for calculating them can be found [here](http://www.isthe.com/chongo/tech/math/number/howhigh.html), or a list can be found [here](http://pastebin.com/8rfxYtZZ).
There is no need to output the exact numbers, this is focused on getting a huge number into a readable format.
For example:
```
10000 = 10.0 thousand
135933445 = 135.93 million
-2 = -2.0
-2.36734603 = -2.37
'1'+'9'*3000 = 2.0 nongennovemnonagintillion
// out of range examples
'1'+'9'*3010 = 20000000000.0 nongennovemnonagintillion
'-1'+'9'*5000 = -inf nongennovemnonagintillion
```
I am aware it is similar to [this](https://codegolf.stackexchange.com/questions/40523/convert-x-illion-into-standard-form) question, though with 10x as many numbers and not having to read the names, there's potentially a lot more room for golfing. For the record, my result is 578 characters in Python.
**Rules:**
* No getting things from external resources - it must all be calculated within the code.
* External modules are fine, just don't break the above rule.
* The code should work when input is either a string, integer or float (eg. you may wish to input the super large numbers as strings).
* The output must always contain a decimal place.
* The output must be rounded if above 2 decimal places. Using the inbuilt round function is fine, I am aware there are some floating point errors, so if the occasional '.045' doesn't round up to '.05' for example, don't worry about it.
* Leaving multiple zeroes at the end is optional, as long as it doesn't go above 2 decimals (1.00 or 1.0 are both fine) and is consistent for all inputs (an input of 1 and 1.0 should output the same result).
* An input too large shouldn't cause an error, `inf` is a valid value since it's part of `float`.
**Scoring:**
* Score is the length of the code, including indents.
* Lowest score wins.
* Output can be either printed or returned.
* Setting the input number does not count towards length.
As a starting point, here is an ungolfed version of some code in Python to generate the list of suffixes. Feel free to build upon this or start from scratch.
```
a = ['', 'un','duo','tre','quattor','quin','sex','septen','octo','novem']
c = ['tillion', 'decillion', 'vigintillion', 'trigintillion', 'quadragintillion', 'quinquagintillion', 'sexagintillion', 'septuagintillion', 'octogintillion', 'nonagintillion']
d = ['', 'cen', 'duocen', 'trecen', 'quadringen', 'quingen', 'sescen', 'septingen', 'octingen', 'nongen']
num_dict = ['']
num_dict.append('thousand')
num_dict.append('million')
num_dict.append('billion')
num_dict.append('trillion')
num_dict.append('quadrillion')
num_dict.append('quintillion')
num_dict.append('sextillion')
num_dict.append('septillion')
num_dict.append('octillion')
num_dict.append('nonillion')
for prefix_hundreds in d:
#tillion can't be used first time round
if not prefix_hundreds:
b = c[1:]
else:
b = c
for prefix_tens in b:
for prefix in a:
num_dict.append(prefix_hundreds+prefix+prefix_tens)
```
[Answer]
To get the ball rolling then, this is my version. Only the final number is converted to a float so there is no problem with large numbers if they're within range.
In terms of speed, it takes about 0.85 seconds to calculate 1000 random integers between -1e3000 and 1e3000.
# Python 2 (574)
```
N=str(X).split('.');K=len;E=min(1000,(K(str(abs(int(N[0]))))-1)/3);P=N[0][:(-E*3if E else K(N[0]))];L=K(P);B=''.join(N);O='%.2f'%float((P+'.'+((B[L:L+3])or'0')));m,n,o,p,q,r,s,t,u,v,w,x,y,z='illion quadr quin sex sept oct non ing ag g tre duo c t'.split();a=[''];l=a+['thousand']+[i+m for i in['m','b','tr',n,o+z,p+z,q,r,s]]+[i+j+k for i in a+[i+'en'for i in[y,x+y,w+y,n+t,o+v,'sesc',q+t,r+t,s+v]]for k in[C+m for C in[z,'dec']+[B+'int'for B in['vig','trig',n+u,o+'quag',p+u,q+'uag',r+'og',s+u]]][not i:]for j in a+['un',x,w,'quattor',o,p,q+'en',r+'o','novem']];print O,l[E]
```
Then with some test cases:
```
>>> X = 100
100.0
>>> X = '100.0'
100.0
>>> X = '1037093920'
1.04 billion
>>> X = '-1540420004036040042.400642'
-1.54 quintillion
>>> X = '1540420' + '0'*153
1.54 duoquinquagintillion
>>> X = '1540496' + '0'*1553
154.05 quingenoctodecillion
Past the limit (just to show it doesn't throw an error and still handles negative value):
>>> X = '-10935' + '6'*3005
-1093566666.67 nongennovemnonagintillion
>>> X = '10935' + '6'*3250
1.09356666667e+254 nongennovemnonagintillion
>>> X = '10935' + '6'*3500
inf nongennovemnonagintillion
```
] |
[Question]
[
(Note: I know that the VSEPR method fails sometimes, and that there are exceptional molecules. The challenge is about the molecules which conform.)
Most people who have taken an introductory chemistry course know about molecules, and (probably) the [VSEPR theory](https://en.wikipedia.org/wiki/VSEPR_theory) of chemical bonding. Basically, the theory predicts the shape of a molecule given three main properties:
* `A`: The central atom. You may assume this is the first element appearing in the chemical formula; for example, in CH4, you may assume the central atom is C.
* `X`: The number of atoms bonded to the central atom A.
* `E`: The number of "lone electron pairs" on the central atom. For the purposes of this challenge, the number of outer electrons A has is given by the last digit of the element's column number on the periodic table.
+ If A is bonded to an element X in column 17 of the periodic table, there will be a mutual sharing of electrons, so that A effectively has one additional electron for each atom of X attached to it. (This does not apply for elements such as O or S in column 16.)
Each bond requires two of these electrons. Leftover electrons not used in bonding with other atoms are found in pairs of two, called lone pairs. So E is the number of electrons not used in bonding by the central atom A divided by 2. (It may be assumed that input will always lead to A having an even number of electrons.)
For example, a molecule which has 1 lone pair and 3 atoms bonded to the main atom is AX3E1, which is the [trigonal pyramidal](https://en.wikipedia.org/wiki/Trigonal_pyramidal_molecular_geometry) configuration. (There is always only 1 central atom, so A never has a subscript.)
## The Challenge
Your job is, given a string representing a covalent chemical compound, to output the shape of that molecule. "*But wait!*", exclaim the exasperated programmers, "*you can't expect us to input all of the molecular data for every element!*" Of course we can, but as that wouldn't be fun, we'll only consider the compounds formed by the following 7 elements:
```
Carbon C
Sulfur S
Oxygen O
Nitrogen N
Chlorine Cl
Bromine Br
Fluorine F
```
The input is any molecule composed of the above 7, such as `CO2` or `SF4`, that is in the form `AXN`, where A and X are each one of the above seven element symbols, X is not `C` or `N`, and N is a number between 2 and 6 inclusive.
The output should be the name of the geometric shape of the molecule, for example "linear".
The following (don't get scared, I swear they're less than they seem!) is a list of all possible configurations along with their AXE number and a drawing of how they look (adapted from Wikipedia's nifty table):
## Test Cases
>
> CO2: CO2 -> linear
>
> OF2: OF2 -> bent
>
> CCl2: CCl2 -> bent
>
> BrF3: BrF3 -> T-shaped
>
> SF4: SF4 -> seesaw
>
>
>
Notes:
- We won't consider compounds in which the first element has a subscript other than 1, such as C2H4.
- Standard loopholes apply.
- This is a code golf, so the shortest answer wins (obviously)
[Answer]
# Ruby, 250
```
s=gets
e=7-"FBOSN C".index(s[0])/2+(s[1]==?l?3:0)
x=s.reverse!.to_i
e+="Frl".index(s[2])?x:0
t="trigonal "
puts [["linear",b="bent",b],[t+"planar",t+p="pyramidal","T-shaped"],["tetr"+h="ahedral","seesaw"],[t+"bi"+p,"square "+p],["oct"+h]][x-2][e/2-x]
```
Note that with the rules as they are, AX2E3 and AX4E2 are not possible with the given elements, so they are not supported. All test cases passed.
**with comments**
```
s=gets #get input with newline attached
e=7-"FBOSN C".index(s[0])/2+(s[1]==?l?3:0) #calculate the number of electrons (not lone pairs) from A. Note the addition required to differentiate C and Cl.
x=s.reverse!.to_i #reverse the input string so the number is at the beginning (after the newline) and evaluate the string as a number to get X.
e+="Frl".index(s[2])?x:0 #if the character after the number is in "Frl" we have a halogen so increment number of electrons accordingly.
t="trigonal " #as "trigonal " goes at the beginning of the string, we cannot define it on the fly, it is defined as a constant here.
#array of outputs below. note the subscripts at the end: x-2 to put it in the range 0..4 and e/2-x to convert e into the actual number of lone pairs.
puts [["linear",b="bent",b],[t+"planar",t+p="pyramidal","T-shaped"],["tetr"+h="ahedral","seesaw"],[t+"bi"+p,"square "+p],["oct"+h]][x-2][e/2-x]
```
] |
[Question]
[
**This question already has answers here**:
[Program to Spoonerise words [duplicate]](/questions/3463/program-to-spoonerise-words)
(7 answers)
Closed 8 years ago.
Here is another short string related code-golf. You must write a full program that reads a string (from STDIN or as command line arguments, as long as you specify which) and wips the flords around (flips the words around). A valid flord wip must
* Flip all of the beginning consonants. (All of the leading consonants up to the first vowel) For example, "Flipping Words" does not become "Wlipping Fords" because this only flips the first letter of each. Instead, it becomes "Wipping Flords"
* Never flip a vowel. For example, "Eating Breakfast" becomes "Breating Eakfast"
* Capitalize the first letter of each output word, and no more. For example 'Stack Overflow' becomes 'Ack Stoverflow', not 'ack StOverflow'.
Your input:
* Will have the first letter of every word capitalized, and all the other letters lowercase.
* Will consist entirely of upper and lowercase letters and spaces.
There will not be any extra or leading spaces.
* There will be no strange consonant only words. For the purposes of this challenge, "y" is a consonant.
* Will have at least 2 words, each separated with a single space. If there are an even number of words, you must flip the first word with the second, the third with the fourth, the fifth with the sixth and so on and so forth. If there are an odd number of words, the same rules apply, and the last word is skipped.
Here are some sample inputs and outputs.
>
> Bunny Rabbit ---> Runny Babbit
>
>
> Programming Puzzles And Code Golf ---> Pogramming Pruzzles Cand Ode Golf
>
>
> The Cake Is A Lie ---> Ce Thake Is A Lie ("Is" and "A" both start with a vowel, so nothing changes. "Lie" is the last odd-word-out so nothing changes)
>
>
> May The Best Golfer Win ---> Thay Me Gest Bolfer Win
>
>
>
[Answer]
# CJam, ~~62~~ 53 bytes
This is too long for now. Will add explanations once I am done golfing.
```
qS%2/{{el__"aeiou"&0=#_2$<@@>}%(a+2/Wf%~}%{s(eu\+}%S*
```
[Try it online here](http://cjam.aditsu.net/#code=qS%252%2F%7B%7Bel__%22aeiou%22%260%3D%23_2%24%3C%40%40%3E%7D%25(a%2B2%2FWf%25~%7D%25%7Bs(eu%5C%2B%7D%25S*&input=May%20The%20Best%20Golfer%20Win)
] |
[Question]
[
**This question already has answers here**:
[Regex in reverse - decompose regular expressions](/questions/25378/regex-in-reverse-decompose-regular-expressions)
(3 answers)
Closed 9 years ago.
Your task, if you accept it, is to make a string generator that generates strings based on a wildcard.
You can make a function or a full program that receives 1 argument and sends to the standard output/console a string that matches.
**Wildcard characters and sequences:**
* `*` produces 0 or more random characters
* `?` produces exactly 1 random character
* `[]` detonates a group and produces any one of the characters from the group, exactly once.
* `[]*` produces at least 0 of the characters from that group
* `[]?` produces any one of the characters from that group, at most once
* `[]{n}` produces `n` characters in that group
* Anything else is a literal string
The supported characters to return are `a-z`, `A-Z` and `0-9`.
Casing doesn't matter.
You can do whatever you want with invalid input.
Examples:
```
f('a[d-f]{3}') //return 'addd', 'adde', 'addf' ...
f('a*') //returns 'a' or anything starting with 'a'
f('[bt]est') //returns 'best', 'test'
```
**Scoring:**
* Shortest code in **bytes** wins.
* -10% bonus if you support symbols
* -10% bonus if you implement multiple matches, inside each group (e.g.: `[ae,c-d,0-5]`)
* -20% bonus if you implement negated group (e.g.: `[^a-f]` returns anything that doesn't start with `a-f`)
* -10% if you support at least 3 regex character classes (e.g.: `\d`,`\s`,`\D`)
* Standard loopholes are **not** allowed!
Any doubts, feel free to ask in a comment.
[Answer]
# Python 3, 511 bytes - 10% = 459.9
It's early morning over here so golfing mode hasn't quite kicked into my system yet, but it was a really fun-looking problem so I thought I'd try it anyway.
```
from random import*
C=0
r=input()
i=0
S=""
Q=""
while i<len(r):
c=r[i]
if i<len(r)-1:d=r[i+1]
if"]"==c:
C=0
if d not in"*?{":S+=choice(Q)
elif"["==c:C=1;Q=""
elif"*"==c:
while random()>.2:S+=choice(Q)
elif"?"==c:S+=choice(Q)*randint(0,1)
elif"{"==c:
a=""
while r[i+1]!="}":a+=r[i+1];i+=1
S+="".join(choice(Q)for _ in range(int(a)))
elif"}"!=c:
if"-"==d:Q+="".join(chr(x)for x in range(ord(c),ord(r[i+2])+1));i+=2
else:
Q=C*Q+c
if not C and d not in"*?{":S+=choice(Q)
i+=1
print(S)
```
I'm claiming the "multiple matches, inside each group" bonus. You can try it out like so:
```
[abA-C0]*
```
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/513/edit).
Closed 7 years ago.
[Improve this question](/posts/513/edit)
Given five points on a straight line such that their pairwise distances are 1,2,4, ..., 14,18,20 (after ordering), find the respective positions of the five points (relative to the furthest point on the left).
[Answer]
**R**
```
prop <- function(num_points, first_distances, last_distances)
{
last_point = max(last_distances)
proposal = c(0, sort(sample(1:(last_point-1), num_points-2)), last_point)
d = sort(dist(proposal))
num_first_distances = length(first_distances)
num_last_distances = length(last_distances)
num_distances = length(d)
if(all(d[1:num_first_distances]==first_distances)&&all(d[(num_distances-num_last_distances+1):num_distances]==last_distances))
{
print(proposal)
return(TRUE)
}
else return(FALSE)
}
while(TRUE)
{
if(prop(5, c(1,2,4), c(14,18,20))) break()
}
```
Here is the [source of the problem](http://xianblog.wordpress.com/2011/02/04/le-monde-puzzle-4/) and an algorithm with R which I used for inspiration.
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/269803/edit).
Closed 10 days ago.
[Improve this question](/posts/269803/edit)
Choose a set `S` of languages from the top 50 languages by [TIOBE Index](https://www.tiobe.com/tiobe-index/) score as of January 2024, and in one of the chosen languages, create a program that takes as input `N=|S|` files, one for each language `L∈S` containing code in `L`, and creates, as output, a file that is a [polyglot](https://en.wikipedia.org/wiki/Polyglot_(computing)) of all chosen languages, and when interpreted/compiled in the language `L∈S`, it's equivalent to the input code in the language `L`.
Submissions are scored as the **sum of TIOBE index scores** (as of January 2024) + 5% for each language.
In case of a tie, the shorter code wins.
For example, here's a simple python code that combines `a.py` and `a.c` into `a`:
```
import re
with open("a.py", "r") as f:
a_py = f.read()
with open("a.c", "r") as f:
a_c = f.read()
result = ('#if 0\n' +
re.sub(r'(?<!\\)#.*\n', '', a_py) +
'\n"""\n#endif\n' +
re.sub(r'(?<!\\)"""', '"', a_c) +
'\n#if 0\n" """\n#endif\n')
with open("a", "w") as f:
f.write(result)
```
This would get a score of 13.97% + 11.44% + 2\*5% = **35.41%**
Failing for extreme edge-cases in the input code (stuff like `//\u000A\u002F\u002A\n//\`) is tolerated.
]
|
[Question]
[
The goal of this challenge is to compare how well different programming languages support functional programming, by seeing how much code it takes to implement BLC8, the simplest functional programming language
BLC8 is the bytewise variant of Binary Lambda Calculus, as described in my 2012 IOCCC entry at <https://www.ioccc.org/2012/tromp/hint.html> :
>
> BLC was developed to make Algorithmic Information Theory, the theory of smallest programs, more concrete. It starts with the simplest model of computation, the lambda calculus, and adds the minimum amount of machinery to enable binary input and output.
>
>
>
>
> More specifically, it defines a universal machine, which, from an input stream of bits, parses the binary encoding of a lambda calculus term, applies that to the remainder of input (translated to a lazy list of booleans, which have a standard representation in lambda calculus), and translates the evaluated result back into a stream of bits to be output.
>
>
>
>
> Lambda is encoded as 00, application as 01, and the variable bound by the n'th enclosing lambda (denoted n in so-called De Bruijn notation) as 1^{n}0. That’s all there is to BLC!
>
>
>
>
> For example the encoding of lambda term S = \x \y \z (x z) (y z), with De Bruijn notation \ \ \ (3 1) (2 1), is 00 00 00 01 01 1110 10 01 110 10
>
>
>
>
> In the closely related BLC8 language, IO is byte oriented, translating between a stream of bytes and a list of length-8 lists of booleans.
>
>
>
A 0 bit is represented by the lambda term B0 = \x0 \x1 x0, or \ \ 2 in De Bruijn notation, while a 1 bit is B1 = \x0 \x1 x1, or \ \ 1 in De Bruijn notation.
The empty list is represented by the lambda term Nil = B1. The pair of terms M and N is represented by the term <M,N> = \z z M N, or \ 1 M N in De Bruijn notation. A list of k terms M1 .. Mk is represented by repeating pairing ending in Nil: <M1, <M2, ... <Mk, Nil> ... >
A byte is represented by the list of its 8 bits from most to least significant. Standard input is represented as a list of bytes, with the end of input (EOF) represented as Nil.
The BLC8 interpreter must parse the encoding of a lambda term from concatenated initial bytes of standard input and apply the parsed term to the remaining bytes of input. Then, assuming that this results in another byte list, that result must be translated back into bytes on standard output.
So it should behave like the IOCCC entry when run without arguments.
Test cases.
On input " Hello" or "\*Hello", the output should be "Hello".
On input of <https://www.ioccc.org/2012/tromp/hilbert.Blc> followed by "123" it should output
```
` _ _ _ _
| |_| | | |_| |
|_ _| |_ _|
_| |_____| |_
| ___ ___ |
|_| _| |_ |_|
_ |_ _| _
| |___| |___| |
```
So my IOCCC entry demonstrated that the programming language C needs 650 characters to implement BLC8 (it also implemented bitwise BLC, but removing that support wouldn't save many characters). It needs that many because C has very poor support for functional programming. No lambdas or closures. BLC itself needs only 43 bytes, demonstrating its much lower functional cost. I would like to see how other languages compare. How many characters does rust need? Or LISP?
]
|
[Question]
[
Given a string of ASCII text as input, encode it in [BPSK31](https://en.wikipedia.org/wiki/PSK31) using [Varicode](https://en.wikipedia.org/wiki/Varicode). You may either output an audio file in any common format, or play the audio over the device speakers. You may output at any sample rate and with any carrier frequency between 500 Hz and 2500 Hz. The sample rate and carrier frequency must be consistent.
## Specifications
### Varicode
Varicode is a character encoding in which characters are given variable-length binary codes, none of which contain the bit sequence `00`; this is because `00` is a separator between consecutive codes. This use of [Fibonacci coding](https://en.wikipedia.org/wiki/Fibonacci_coding) enables more commonly-used letters to be given shorter codes in a simple form of compression. All ASCII characters, including both printable and control characters, are supported by Varicode.
### Control characters
| Varicode | Oct | Dec | Hex | Abbr | Description |
| --- | --- | --- | --- | --- | --- |
| 1010101011 | 000 | 0 | 00 | NUL | Null character |
| 1011011011 | 001 | 1 | 01 | SOH | Start of Header |
| 1011101101 | 002 | 2 | 02 | STX | Start of Text |
| 1101110111 | 003 | 3 | 03 | ETX | End of Text |
| 1011101011 | 004 | 4 | 04 | EOT | End of Transmission |
| 1101011111 | 005 | 5 | 05 | ENQ | Enquiry |
| 1011101111 | 006 | 6 | 06 | ACK | Acknowledgment |
| 1011111101 | 007 | 7 | 07 | BEL | Bell |
| 1011111111 | 010 | 8 | 08 | BS | Backspace |
| 11101111 | 011 | 9 | 09 | HT | Horizontal Tab |
| 11101 | 012 | 10 | 0A | LF | Line feed |
| 1101101111 | 013 | 11 | 0B | VT | Vertical Tab |
| 1011011101 | 014 | 12 | 0C | FF | Form feed |
| 11111 | 015 | 13 | 0D | CR | Carriage return |
| 1101110101 | 016 | 14 | 0E | SO | Shift Out |
| 1110101011 | 017 | 15 | 0F | SI | Shift In |
| 1011110111 | 020 | 16 | 10 | DLE | Data Link Escape |
| 1011110101 | 021 | 17 | 11 | DC1 | Device Control 1 (XON) |
| 1110101101 | 022 | 18 | 12 | DC2 | Device Control 2 |
| 1110101111 | 023 | 19 | 13 | DC3 | Device Control 3 (XOFF) |
| 1101011011 | 024 | 20 | 14 | DC4 | Device Control 4 |
| 1101101011 | 025 | 21 | 15 | NAK | Negative Acknowledgement |
| 1101101101 | 026 | 22 | 16 | SYN | Synchronous Idle |
| 1101010111 | 027 | 23 | 17 | ETB | End of Trans. Block |
| 1101111011 | 030 | 24 | 18 | CAN | Cancel |
| 1101111101 | 031 | 25 | 19 | EM | End of Medium |
| 1110110111 | 032 | 26 | 1A | SUB | Substitute |
| 1101010101 | 033 | 27 | 1B | ESC | Escape |
| 1101011101 | 034 | 28 | 1C | FS | File Separator |
| 1110111011 | 035 | 29 | 1D | GS | Group Separator |
| 1011111011 | 036 | 30 | 1E | RS | Record Separator |
| 1101111111 | 037 | 31 | 1F | US | Unit Separator |
| 1110110101 | 177 | 127 | 7F | DEL | Delete |
### Printable characters
| Varicode | Oct | Dec | Hex | Glyph |
| --- | --- | --- | --- | --- |
| 1 | 040 | 32 | 20 | SP |
| 111111111 | 041 | 33 | 21 | ! |
| 101011111 | 042 | 34 | 22 | " |
| 111110101 | 043 | 35 | 23 | # |
| 111011011 | 044 | 36 | 24 | $ |
| 1011010101 | 045 | 37 | 25 | % |
| 1010111011 | 046 | 38 | 26 | & |
| 101111111 | 047 | 39 | 27 | ' |
| 11111011 | 050 | 40 | 28 | ( |
| 11110111 | 051 | 41 | 29 | ) |
| 101101111 | 052 | 42 | 2A | \* |
| 111011111 | 053 | 43 | 2B | + |
| 1110101 | 054 | 44 | 2C | , |
| 110101 | 055 | 45 | 2D | - |
| 1010111 | 056 | 46 | 2E | . |
| 110101111 | 057 | 47 | 2F | / |
| 10110111 | 060 | 48 | 30 | 0 |
| 10111101 | 061 | 49 | 31 | 1 |
| 11101101 | 062 | 50 | 32 | 2 |
| 11111111 | 063 | 51 | 33 | 3 |
| 101110111 | 064 | 52 | 34 | 4 |
| 101011011 | 065 | 53 | 35 | 5 |
| 101101011 | 066 | 54 | 36 | 6 |
| 110101101 | 067 | 55 | 37 | 7 |
| 110101011 | 070 | 56 | 38 | 8 |
| 110110111 | 071 | 57 | 39 | 9 |
| 11110101 | 072 | 58 | 3A | : |
| 110111101 | 073 | 59 | 3B | ; |
| 111101101 | 074 | 60 | 3C | < |
| 1010101 | 075 | 61 | 3D | = |
| 111010111 | 076 | 62 | 3E | > |
| 1010101111 | 077 | 63 | 3F | ? |
| 1010111101 | 100 | 64 | 40 | @ |
| 1111101 | 101 | 65 | 41 | A |
| 11101011 | 102 | 66 | 42 | B |
| 10101101 | 103 | 67 | 43 | C |
| 10110101 | 104 | 68 | 44 | D |
| 1110111 | 105 | 69 | 45 | E |
| 11011011 | 106 | 70 | 46 | F |
| 11111101 | 107 | 71 | 47 | G |
| 101010101 | 110 | 72 | 48 | H |
| 1111111 | 111 | 73 | 49 | I |
| 111111101 | 112 | 74 | 4A | J |
| 101111101 | 113 | 75 | 4B | K |
| 11010111 | 114 | 76 | 4C | L |
| 10111011 | 115 | 77 | 4D | M |
| 11011101 | 116 | 78 | 4E | N |
| 10101011 | 117 | 79 | 4F | O |
| 11010101 | 120 | 80 | 50 | P |
| 111011101 | 121 | 81 | 51 | Q |
| 10101111 | 122 | 82 | 52 | R |
| 1101111 | 123 | 83 | 53 | S |
| 1101101 | 124 | 84 | 54 | T |
| 101010111 | 125 | 85 | 55 | U |
| 110110101 | 126 | 86 | 56 | V |
| 101011101 | 127 | 87 | 57 | W |
| 101110101 | 130 | 88 | 58 | X |
| 101111011 | 131 | 89 | 59 | Y |
| 1010101101 | 132 | 90 | 5A | Z |
| 111110111 | 133 | 91 | 5B | [ |
| 111101111 | 134 | 92 | 5C | \ |
| 111111011 | 135 | 93 | 5D | ] |
| 1010111111 | 136 | 94 | 5E | ^ |
| 101101101 | 137 | 95 | 5F | \_ |
| 1011011111 | 140 | 96 | 60 | ' |
| 1011 | 141 | 97 | 61 | a |
| 1011111 | 142 | 98 | 62 | b |
| 101111 | 143 | 99 | 63 | c |
| 101101 | 144 | 100 | 64 | d |
| 11 | 145 | 101 | 65 | e |
| 111101 | 146 | 102 | 66 | f |
| 1011011 | 147 | 103 | 67 | g |
| 101011 | 150 | 104 | 68 | h |
| 1101 | 151 | 105 | 69 | i |
| 111101011 | 152 | 106 | 6A | j |
| 10111111 | 153 | 107 | 6B | k |
| 11011 | 154 | 108 | 6C | l |
| 111011 | 155 | 109 | 6D | m |
| 1111 | 156 | 110 | 6E | n |
| 111 | 157 | 111 | 6F | o |
| 111111 | 160 | 112 | 70 | p |
| 110111111 | 161 | 113 | 71 | q |
| 10101 | 162 | 114 | 72 | r |
| 10111 | 163 | 115 | 73 | s |
| 101 | 164 | 116 | 74 | t |
| 110111 | 165 | 117 | 75 | u |
| 1111011 | 166 | 118 | 76 | v |
| 1101011 | 167 | 119 | 77 | w |
| 11011111 | 170 | 120 | 78 | x |
| 1011101 | 171 | 121 | 79 | y |
| 111010101 | 172 | 122 | 7A | z |
| 1010110111 | 173 | 123 | 7B | { |
| 110111011 | 174 | 124 | 7C | | |
| 1010110101 | 175 | 125 | 7D | } |
| 1011010111 | 176 | 126 | 7E | ~ |
### PSK31
BPSK31, the most common variant of PSK31, modulates the phase of a constant carrier wave to transmit the information. Every 32 ms, the phase of the carrier is either changed by 180°, representing a binary 1, or left unchanged, representing a binary zero. The signal is filtered with a [raised-cosine filter](https://en.wikipedia.org/wiki/Raised-cosine_filter) to reduce interference.
## Test cases
### Varicode
| Input | Varicode |
| --- | --- |
| `Code Golf` | `10101101001110010110100110010011111101001110011011111101` |
| `CQ` | `1010110100111011101` |
### PSK31
Unfortunately, there's really no way to give test cases for the modulation itself, because the output doesn't have to precisely match a particular value. However, for testing, you can use [Fldigi](http://www.w1hkj.com/) to decode your results.
]
|
[Question]
[
Anyone got tips for golfing in [Thue](https://esolangs.org/wiki/Thue). One tip per answer, and no tips aplicable to all languages (like remove comments)
]
|
[Question]
[
I have made a short script that will pull dns txt records down from a server and combine them into a single string.
DNS txt records are:
`1.website.com`
`2.website.com`
`3.website.com`
Each of these are iterated through using the single digit number.
The double quotes at the beginning and the end of the strings are trimmed
This works exactly as I would like it too
I am simply interested in seeing how short I can get it
```
$i = 1
1..2 | foreach {
$w="$i.website.com"
sv -N v -Va ((nslookup -q=txt $w )[-1]).Trim().Trim('"')
$p += "$v"
$i += 1
}
```
and ideally I'd like to return the `$p` variable, that being the concatenated string
this is what I ended getting it down to
```
1..2|%{$p+=Resolve-DnsName "$_.website.com." -Ty TXT -EA 0|% S*s};powershell .($p)
```
]
|
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
This question does not appear to be about code golf or coding challenges within the scope defined in the [help center](https://codegolf.stackexchange.com/help/on-topic).
Closed 6 months ago.
[Improve this question](/posts/250553/edit)
It is known that any natural number can be decomposed into the sum of three triangular numbers (assuming 0 is triangular), according to [Fermat's Polygonal Number Theorem](https://en.wikipedia.org/wiki/Fermat_polygonal_number_theorem). Your task is to come up with an algorithm of decomposing number into 3 triangular numbers that has the best asymptotic complexity. As an input you are given a number N. Output should contain three numbers, they must be triangular(or 0) and sum of them must be equal to number given in the input.
---
The difference between this [question](https://codegolf.stackexchange.com/questions/132834/three-triangular-numbers) and mine is that my question isn't code-golf.
]
|
[Question]
[
It is well known, in the field of Mathematics studying infinity, that [the Cartesian product of any finite amount of countable sets is also countable](https://proofwiki.org/wiki/Cartesian_Product_of_Countable_Sets_is_Countable/Corollary).
Your task is to write two programs to implement this, one to map from list to integer, one to map from integer to list.
Your function must be bijective and deterministic, meaning that `1` will always map to a certain list, and `2` will always map to another certain list, etc...
[Earlier](https://codegolf.stackexchange.com/questions/71924/bijective-mapping-from-integers-to-a-variable-number-of-bits), we mapped integers to a list consisting only of `0` and `1`.
**However, now the list will consist of non-negative numbers.**
# Specs
* Program/function, reasonable input/output format.
* Whether the mapped integers start from `1` or starts from `0` is your choice, meaning that `0` doesn't have to (but may) map to anything.
* The empty array `[]` must be encoded.
* Input/output may be in any base.
* Sharing code between the two functions is **allowed**.
# Scoring
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"). Lowest score wins.
Score is the sum of lengths (in bytes) of the two programs/functions.
[Answer]
# [Jelly](http://github.com/DennisMitchell/jelly), ~~18~~ 16 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
### List to integer, ~~10~~ 8 bytes
```
TṪạL;³ÆẸ
```
Maps lists of non-negative integers to positive integers. [Try it online!](http://jelly.tryitonline.net/#code=VOG5quG6oUw7wrPDhuG6uA&input=&args=WzAsIDEsIDIsIDMsIDBd)
### Integer to list, 8 bytes
```
ÆE©Ḣ0ẋ®;
```
Maps positive integers to lists of non-negative integers . [Try it online!](http://jelly.tryitonline.net/#code=w4ZFwqnhuKIw4bqLwq47&input=&args=NjUyMTkw)
## Background
Let **p0, p1, p2, ⋯** be the sequence of prime numbers in ascending order.
For each list of non-negative integers **A := [a1, ⋯, an]**, we map **A** to **p0z(A)p1a1⋯pnan**, where **z(A)** is the number of trailing zeroes of **A**.
Reversing the above map in straightforward. For a *positive* integer **k**, we factorize it uniquely as the product of consecutive prime powers **n = p0α0p1α1⋯pnαn**, where **αn > 0**, then reconstruct the list as **[α1, ⋯, αn]**, appending **α0** zeroes.
## How it works
### List to integer
```
TṪạL;³ÆẸ Main link. Argument: A (list of non-negative integers)
T Yield all indices of A that correspond to truthy (i.e., non-zero) items.
Ṫ Tail; select the last truthy index.
This returns 0 if the list is empty.
L Yield the length of A.
ạ Compute the absolute difference of the last truthy index and the length.
This yields the amount of trailing zeroes of A.
;³ Prepend the difference to A.
ÆẸ Convert the list from prime exponents to integer.
```
### Integer to list
```
ÆE©Ḣ0ẋ®; Main link. Input: k (positive integer)
ÆE Convert k to the list of its prime exponents.
© Save the list of prime exponents in the register.
Ḣ Head; pop the first exponent.
If the list is empty, this yields 0.
0ẋ Construct a list of that many zeroes.
®; Concatenate the popped list of exponents with the list of zeroes.
```
## Example output
The first one hundred positive integers map to the following lists.
```
1: []
2: [0]
3: [1]
4: [0, 0]
5: [0, 1]
6: [1, 0]
7: [0, 0, 1]
8: [0, 0, 0]
9: [2]
10: [0, 1, 0]
11: [0, 0, 0, 1]
12: [1, 0, 0]
13: [0, 0, 0, 0, 1]
14: [0, 0, 1, 0]
15: [1, 1]
16: [0, 0, 0, 0]
17: [0, 0, 0, 0, 0, 1]
18: [2, 0]
19: [0, 0, 0, 0, 0, 0, 1]
20: [0, 1, 0, 0]
21: [1, 0, 1]
22: [0, 0, 0, 1, 0]
23: [0, 0, 0, 0, 0, 0, 0, 1]
24: [1, 0, 0, 0]
25: [0, 2]
26: [0, 0, 0, 0, 1, 0]
27: [3]
28: [0, 0, 1, 0, 0]
29: [0, 0, 0, 0, 0, 0, 0, 0, 1]
30: [1, 1, 0]
31: [0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
32: [0, 0, 0, 0, 0]
33: [1, 0, 0, 1]
34: [0, 0, 0, 0, 0, 1, 0]
35: [0, 1, 1]
36: [2, 0, 0]
37: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
38: [0, 0, 0, 0, 0, 0, 1, 0]
39: [1, 0, 0, 0, 1]
40: [0, 1, 0, 0, 0]
41: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
42: [1, 0, 1, 0]
43: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
44: [0, 0, 0, 1, 0, 0]
45: [2, 1]
46: [0, 0, 0, 0, 0, 0, 0, 1, 0]
47: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
48: [1, 0, 0, 0, 0]
49: [0, 0, 2]
50: [0, 2, 0]
51: [1, 0, 0, 0, 0, 1]
52: [0, 0, 0, 0, 1, 0, 0]
53: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
54: [3, 0]
55: [0, 1, 0, 1]
56: [0, 0, 1, 0, 0, 0]
57: [1, 0, 0, 0, 0, 0, 1]
58: [0, 0, 0, 0, 0, 0, 0, 0, 1, 0]
59: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
60: [1, 1, 0, 0]
61: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
62: [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]
63: [2, 0, 1]
64: [0, 0, 0, 0, 0, 0]
65: [0, 1, 0, 0, 1]
66: [1, 0, 0, 1, 0]
67: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
68: [0, 0, 0, 0, 0, 1, 0, 0]
69: [1, 0, 0, 0, 0, 0, 0, 1]
70: [0, 1, 1, 0]
71: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
72: [2, 0, 0, 0]
73: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
74: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]
75: [1, 2]
76: [0, 0, 0, 0, 0, 0, 1, 0, 0]
77: [0, 0, 1, 1]
78: [1, 0, 0, 0, 1, 0]
79: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
80: [0, 1, 0, 0, 0, 0]
81: [4]
82: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]
83: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
84: [1, 0, 1, 0, 0]
85: [0, 1, 0, 0, 0, 1]
86: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]
87: [1, 0, 0, 0, 0, 0, 0, 0, 1]
88: [0, 0, 0, 1, 0, 0, 0]
89: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
90: [2, 1, 0]
91: [0, 0, 1, 0, 1]
92: [0, 0, 0, 0, 0, 0, 0, 1, 0, 0]
93: [1, 0, 0, 0, 0, 0, 0, 0, 0, 1]
94: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]
95: [0, 1, 0, 0, 0, 0, 1]
96: [1, 0, 0, 0, 0, 0]
97: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
98: [0, 0, 2, 0]
99: [2, 0, 0, 1]
100: [0, 2, 0, 0]
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~13~~ 12 bytes
## Encode, ~~7~~ 6 bytes
```
2Bṁx‘Ḅ
```
[Try it online!](https://tio.run/##y0rNyan8/9/I6eHOxopHDTMe7mj5//9/tIGOoY6JjqWOoZmOkamOsZmOiaWOmYmOhaGOoYFBLAA "Jelly – Try It Online")
## Decode, 6 bytes
```
ȯIBŒɠ’
```
[Try it online!](https://tio.run/##HYyxDUJRDMRWyiW5JNfSMQgN@gvQMQMdHRswBRKswSKPL0pLts@nbbus9X4eD6/b5/G93tdaMPNQQAl6t8/UpEPyKoBBaxUrsiLaMZ2TjL0iIts0liT2x45ilIQiwzKpaJvq/AuwrglNC9mEfg "Jelly – Try It Online")
Encodes positive integers in the run lengths of the binary representation. Since we may have zeros, we increment all numbers. For example, the list `[0,1,4]` is encoded as 10011111 in binary.
Numbers from 0 to 100 ([Try it online!](https://tio.run/##y0rNyan8///Eek@no5NOLnjUMPO/oYHB0d06h9uPTnq4c8ajpjXHuoCE@///AA "Jelly – Try It Online")):
```
0 []
1 [0]
2 [0, 0]
3 [1]
4 [0, 1]
5 [0, 0, 0]
6 [1, 0]
7 [2]
8 [0, 2]
9 [0, 1, 0]
10 [0, 0, 0, 0]
11 [0, 0, 1]
12 [1, 1]
13 [1, 0, 0]
14 [2, 0]
15 [3]
16 [0, 3]
17 [0, 2, 0]
18 [0, 1, 0, 0]
19 [0, 1, 1]
20 [0, 0, 0, 1]
21 [0, 0, 0, 0, 0]
22 [0, 0, 1, 0]
23 [0, 0, 2]
24 [1, 2]
25 [1, 1, 0]
26 [1, 0, 0, 0]
27 [1, 0, 1]
28 [2, 1]
29 [2, 0, 0]
30 [3, 0]
31 [4]
32 [0, 4]
33 [0, 3, 0]
34 [0, 2, 0, 0]
35 [0, 2, 1]
36 [0, 1, 0, 1]
37 [0, 1, 0, 0, 0]
38 [0, 1, 1, 0]
39 [0, 1, 2]
40 [0, 0, 0, 2]
41 [0, 0, 0, 1, 0]
42 [0, 0, 0, 0, 0, 0]
43 [0, 0, 0, 0, 1]
44 [0, 0, 1, 1]
45 [0, 0, 1, 0, 0]
46 [0, 0, 2, 0]
47 [0, 0, 3]
48 [1, 3]
49 [1, 2, 0]
50 [1, 1, 0, 0]
51 [1, 1, 1]
52 [1, 0, 0, 1]
53 [1, 0, 0, 0, 0]
54 [1, 0, 1, 0]
55 [1, 0, 2]
56 [2, 2]
57 [2, 1, 0]
58 [2, 0, 0, 0]
59 [2, 0, 1]
60 [3, 1]
61 [3, 0, 0]
62 [4, 0]
63 [5]
64 [0, 5]
65 [0, 4, 0]
66 [0, 3, 0, 0]
67 [0, 3, 1]
68 [0, 2, 0, 1]
69 [0, 2, 0, 0, 0]
70 [0, 2, 1, 0]
71 [0, 2, 2]
72 [0, 1, 0, 2]
73 [0, 1, 0, 1, 0]
74 [0, 1, 0, 0, 0, 0]
75 [0, 1, 0, 0, 1]
76 [0, 1, 1, 1]
77 [0, 1, 1, 0, 0]
78 [0, 1, 2, 0]
79 [0, 1, 3]
80 [0, 0, 0, 3]
81 [0, 0, 0, 2, 0]
82 [0, 0, 0, 1, 0, 0]
83 [0, 0, 0, 1, 1]
84 [0, 0, 0, 0, 0, 1]
85 [0, 0, 0, 0, 0, 0, 0]
86 [0, 0, 0, 0, 1, 0]
87 [0, 0, 0, 0, 2]
88 [0, 0, 1, 2]
89 [0, 0, 1, 1, 0]
90 [0, 0, 1, 0, 0, 0]
91 [0, 0, 1, 0, 1]
92 [0, 0, 2, 1]
93 [0, 0, 2, 0, 0]
94 [0, 0, 3, 0]
95 [0, 0, 4]
96 [1, 4]
97 [1, 3, 0]
98 [1, 2, 0, 0]
99 [1, 2, 1]
100 [1, 1, 0, 1]
```
[Answer]
# Python 2, 88 bytes
```
d=lambda n:map(len,bin(n).split('1')[1:])
e=lambda l:int('1'.join(a*'0'for a in[2]+l),2)
```
Demo:
```
>>> for i in range(33):
... print e(d(i)), d(i)
...
0 []
1 [0]
2 [1]
3 [0, 0]
4 [2]
5 [1, 0]
6 [0, 1]
7 [0, 0, 0]
8 [3]
9 [2, 0]
10 [1, 1]
11 [1, 0, 0]
12 [0, 2]
13 [0, 1, 0]
14 [0, 0, 1]
15 [0, 0, 0, 0]
16 [4]
17 [3, 0]
18 [2, 1]
19 [2, 0, 0]
20 [1, 2]
21 [1, 1, 0]
22 [1, 0, 1]
23 [1, 0, 0, 0]
24 [0, 3]
25 [0, 2, 0]
26 [0, 1, 1]
27 [0, 1, 0, 0]
28 [0, 0, 2]
29 [0, 0, 1, 0]
30 [0, 0, 0, 1]
31 [0, 0, 0, 0, 0]
32 [5]
```
# Python 2, 130 bytes
Here’s a more “efficient” solution where the bit-length of the output is linear in the bit-length of the input rather than exponential.
```
def d(n):m=-(n^-n);return d(n/m/m)+[n/m%m+m-2]if n else[]
e=lambda l:int('0'+''.join(bin(2*a+5<<len(bin(a+2))-4)[3:]for a in l),2)
```
[Answer]
# Python 2, 204 202 bytes
```
p=lambda x,y:(2*y+1<<x)-1
u=lambda n,x=0:-~n%2<1and u(-~n//2-1,x+1)or[x,n//2]
e=lambda l:l and-~reduce(p,l,len(l)-1)or 0
def d(n):
if n<1:return[]
r=[];n,l=u(n-1);exec"n,e=u(n);r=[e]+r;"*l;return[n]+r
```
Works by repeatedly applying a Z+ x Z+ <-> Z+ bijection, prepended by the list length.
```
0: []
1: [0]
2: [1]
3: [0, 0]
4: [2]
5: [0, 0, 0]
6: [1, 0]
7: [0, 0, 0, 0]
8: [3]
9: [0, 0, 0, 0, 0]
10: [1, 0, 0]
11: [0, 0, 0, 0, 0, 0]
12: [0, 1]
13: [0, 0, 0, 0, 0, 0, 0]
14: [1, 0, 0, 0]
15: [0, 0, 0, 0, 0, 0, 0, 0]
16: [4]
17: [0, 0, 0, 0, 0, 0, 0, 0, 0]
18: [1, 0, 0, 0, 0]
19: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
20: [0, 0, 1]
21: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
22: [1, 0, 0, 0, 0, 0]
23: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
24: [2, 0]
25: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
26: [1, 0, 0, 0, 0, 0, 0]
27: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
28: [0, 0, 0, 1]
29: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
30: [1, 0, 0, 0, 0, 0, 0, 0]
31: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
```
[Answer]
# Retina, 17 + 23 = 40 bytes
From list to integer:
```
\d+
$&$*0
^
1
1
```
[Try it online!](http://retina.tryitonline.net/#code=XGQrCiQmJCowCl4KMQogCjE&input=MCAxIDIgMyAwIDUgMA)
From integer to list:
```
^1
S`1
m`^(0*)
$.1
¶
<space>
```
[Try it online!](http://retina.tryitonline.net/#code=XjEKClNgMQptYF4oMCopCiQuMQrCtgog&input=MTEwMTAwMTAwMDExMDAwMDAx)
Uses [Kaseorg's Algorithm](https://codegolf.stackexchange.com/a/78989/48934).
[Answer]
# JavaScript, 87 bytes
```
F=n=>n.toString(2).split(1).slice(1).map(_=>_.length)
G=a=>g=(i=0)=>F(i)+''==a?i:g(++i)
```
`G` goes through all inputs since it's shorter
] |
[Question]
[
[Fennel](https://fennel-lang.org/) is a lispy language which compiles to Lua.
From its page:
>
> Fennel is a programming language that brings together the speed, simplicity, and reach of Lua with the flexibility of a lisp syntax and macro system.
>
>
>
I am looking for general tips for golfing in this language. Tips should be specific to Fennel, "Remove comments and whitespace" is not an answer. If you are giving a general lisp tip then [post it here](https://codegolf.stackexchange.com/questions/79719/tips-for-golfing-in-lisp)
]
|
[Question]
[
# Introduction
There have been a few examples of the smallest possible OCI container that does "X". However these examples never correctly handle termination signals.
# Challenge
Produce the smallest possible container that correctly handles PID 1 signal responsibilities.
The container does not need to manage child processes.
The container does not need to emit anything to stdout.
It merely needs to start and stay "running" until any graceful termination signal arrives and then exit with exit code 0.
If any non graceful termination signal arrives it should respond per convention.
It should not use CPU unnecessarily. I expect solutions that "sleep" would take less code anyway. Extra bonus kudos for figuring out how to not block or occupy any threads.(Probably not possible, but I don't know enough about this area to say for sure.)
You my use any container build system.
# Example Naive Incorrect Solution
```
//a.c
#include <signal.h>
int main() {
pause(); //does not handle signals at all, never returns, only dies on SIGKILL
return 0;
}
```
```
# Dockerfile
FROM alpine AS build
RUN \
apk update && \
apk add --no-cache build-base
COPY a.c .
RUN gcc -o a -Wall -s a.c --static
FROM scratch
COPY --from=build a .
CMD ["/a"]
```
# Test Protocol
`start`
```
> docker create --name tiny <image:tag>
> docker start tiny
> docker stop tiny
# should exit immediately
> docker inspect tiny --format='{{.State.ExitCode}}'
# should return 0
> docker rm tiny
```
`run`
```
> docker run --name tiny
^C # Control-C
# should exit immediately
> docker inspect tiny --format='{{.State.ExitCode}}'
# should return 0
> docker rm tiny
```
`SIGHUP`, `SIGQUIT`, [Job Control Signals](https://www.gnu.org/software/libc/manual/html_node/Job-Control-Signals.html)
```
# TBD - I will accept entries that ignore these
# bonus kudos if you provide an alternate that includes appropriate handling of these signals
```
# Winning Condition
* Container correctly reacts to `SIGINT` and `SIGTERM` [Termination Signals](https://www.gnu.org/software/libc/manual/html_node/Termination-Signals.html)
* Smallest size as shown with `docker image inspect --format='{{.Size}}' <image:tag>`
* Source code size is NOT considered
* Build files sizes are NOT considered
* Only resulting image size is scored
References:
* <https://idbs-engineering.com/docker/containers/2021/01/28/container-competition.html>
* <https://jpetazzo.github.io/2020/02/01/quest-minimal-docker-images-part-1/>
* <https://devopsdirective.com/posts/2021/04/tiny-container-image/>
* [https://www.muppetlabs.com/~breadbox/software/tiny/teensy.html](https://www.muppetlabs.com/%7Ebreadbox/software/tiny/teensy.html)
* <https://stackoverflow.com/questions/53382589/smallest-executable-program-x86-64>
* <https://docs.docker.com/engine/reference/run/#specify-an-init-process>
* <https://www.gnu.org/software/libc/manual/html_node/Signal-Handling.html>
* <https://github.com/krallin/tini>
* <https://github.com/Yelp/dumb-init>
* <https://github.com/GoogleContainerTools/distroless/issues/550#issuecomment-791610603>
* <https://www.google.com/search?q=pid+1+container>
]
|
[Question]
[
Given the equation of a non-parabolic conic section, output its characteristics.
---
# Spec
Some info on conic sections:
*for more info visit [Wikipedia](https://en.wikipedia.org/wiki/Conic_section)*
From an equation of the form \$ax^2+bx+cy^2+dy+E=0\$, it is possible to derive the type of conic section using a combination of square completion and simple arithmetic.
For the example \$x^2+6x+y^2+8y+16=0\$, here is how you would go about it.
\$(x^2+6x+9) + (y^2+8y+16) - 9=0\$
\$ => (x+3)^2 + (y+4)^2 = 9\$
\$ => \frac{(x+3)^2}{3^2}+\frac{(y+4)^2}{3^2}=1\$ (standard form)
=> this is an ellipse. The horizontal radius and vertical radius are the denominators of the first and second fractions, respectively. The center can be derived by calculating the \$x\$ and \$y\$ values such that each fraction evaluates to zero, in this case \$(-3,-4)\$ is the center. The foci can also be calculated at a distance of \$\sqrt{a^2-b^2}\$ for ellipses and \$\sqrt{a^2+b^2}\$ for hyperbolas, where a and b are the horizontal/vertical radii, respectively. In this case only one focus exists, which is the center (the above section is actually a *circle*, a special case with *eccentricity* of 0. This can be calculated via either \$\frac{\sqrt{a^2+b^2}}{a}\$ for hyperbolas or \$\frac{\sqrt{a^2-b^2}}{a}\$ for ellipses.
To determine if a section is an ellipse or a hyperbola, you can take the *discriminant* of the equation, which is defined as \$b^2-ac\$. If the discriminant is greater than 0, the equation represents a hyperbola. If less than 0, an ellipse and if equal to 0 a parabola. (We are not handling parabolas, to simplify things.)
No degenerate conic sections will be given as input.
## Input
A non-parabolic (to simplify things) conic section given in the standard equation form. To simplify things further (because the main point is not to perform linear algebra magic) there will be no `xy` term. This is an example of a valid equation:
```
x^2+6x+y^2-8y+15=0 // string form
[1,6,1,-8,15] // array form
```
These are not:
```
x^3+5x^2+7x+4=0 // because the degree of the equation is 2
x^2+5xy+y^2-4=0 // is a hyperbola, but there should be no `xy` term
x^2+3x+7=0 // because there should be `x` and `y` terms.
```
Note that the conic section can also be taken as an array as shown above. If so, please specify the order of the array; I am flexible when it comes to this format, As long as there are 5 elements with nonexistent terms represented by zero (like no `y` term in `x^2+5x+y^2+14=0`) and that the terms they represent are `x^2 x y^2 y c` where `c` is a constant. The equation will always be `<expression> = 0`.
## Output
Output should be the type of section, center, horizontal radius, vertical radius, foci and eccentricity (in whatever desired order). This can be output as a string or an array as long as it is clear. A valid output for `x^2+6x+y^2+8y+16=0` (or its array equivalent) would be:
```
["ellipse", [-3, -4], 3, 3, [[-3, -4]], 0]
```
or
```
ellipse
-3 -4
3
3
-3 -4
0
```
or similar.
(no need to output "circle" because it is a special case of the ellipse)
Another case [assumes equation form]:
Floating point errors for eccentricity are fine, but here shown in mathematical notation.
```
Input: 9x^2-4y^2+72x+32y+44=0
Output:
hyperbola
-4 4
2
3
-4+sqrt(13)/2
-4-sqrt(13)/2
sqrt(13)/2
```
]
|
[Question]
[
The ***[Catalan numbers](https://en.wikipedia.org/wiki/Catalan_number)*** ([OEIS](https://oeis.org/A000108)) are a sequence of natural numbers often appearing in combinatorics.
The nth Catalan number is the number of Dyck words (balanced strings of parenthesis or brackets such as `[[][]]`; formally defined as a string using two characters `a` and `b` such that any substring starting from the beginning has number of `a` characters greater than or equal to number of `b` characters, and the entire string has the same number of `a` and `b` characters) with length `2n`. The nth Catalan number (for \$n\ge0\$) is also explicitly defined as:
$$C\_n=\frac1{n+1}\binom{2n}n$$
Starting from \$n=0\$, the first 20 Catalan numbers are:
```
1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845, 35357670, 129644790, 477638700, 1767263190...
```
# Challenge
Write a full program or function that takes a non-negative integer `n` via STDIN or an acceptable alternative, and outputs the nth Catalan number. Your program must work at minimum for inputs `0-19`.
## I/O
### Input
Your program must take input from STDIN, function arguments or any of the acceptable alternatives [per this meta post.](http://meta.codegolf.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods) You can read the inputted number as its standard decimal represention, unary representation, or bytes.
* If (and only if) your language cannot take input from STDIN or any acceptable alternative, it may take input from a hardcoded variable or suitable equivalent in the program.
### Output
Your program must output the nth Catalan number to STDOUT, function result or any of the acceptable alternatives [per this meta post.](http://meta.codegolf.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods) You can output the Catalan number in its standard decimal representation, unary representation or bytes.
The output should consist of the approriate Catalan number, optionally followed by one or more newlines. No other output can be generated, except constant output of your language's interpreter that cannot be suppressed (such as a greeting, ANSI color codes or indentation).
---
This is not about finding the language that is the shortest. This is about finding the shortest program in every language. Therefore, I will not accept an answer.
In this challenge, languages newer than the challenge are acceptable **as long as they have an implementation.** It is allowed (and even encouraged) to write this interpreter yourself for a previously unimplemented language. Other than that, all the standard rules of [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") must be obeyed. Submissions in most languages will be scored in bytes in an appropriate preexisting encoding (usually UTF-8). Note also that built-ins for calculating the nth Catalan number are allowed.
# Catalog
The Stack Snippet at the bottom of this post generates the catalogue from the answers a) as a list of shortest solution per language and b) as an overall leaderboard.
To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:
```
## Language Name, N bytes
```
where `N` is the size of your submission. If you improve your score, you *can* keep old scores in the headline, by striking them through. For instance:
```
## Ruby, <s>104</s> <s>101</s> 96 bytes
```
If there you want to include multiple numbers in your header (e.g. because your score is the sum of two files or you want to list interpreter flag penalties separately), make sure that the actual score is the *last* number in the header:
```
## Perl, 43 + 2 (-p flag) = 45 bytes
```
You can also make the language name a link which will then show up in the snippet:
```
## [><>](http://esolangs.org/wiki/Fish), 121 bytes
```
```
<style>body { text-align: left !important} #answer-list { padding: 10px; width: 290px; float: left; } #language-list { padding: 10px; width: 290px; float: left; } table thead { font-weight: bold; } table td { padding: 5px; }</style><script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="language-list"> <h2>Shortest Solution by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr> </thead> <tbody id="languages"> </tbody> </table> </div> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr> </thead> <tbody id="answers"> </tbody> </table> </div> <table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table><script>var QUESTION_ID = 66127; var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe"; var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk"; var OVERRIDE_USER = 12012; var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page; function answersUrl(index) { return "https://api.stackexchange.com/2.2/questions/" + QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER; } function commentUrl(index, answers) { return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER; } function getAnswers() { jQuery.ajax({ url: answersUrl(answer_page++), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { answers.push.apply(answers, data.items); answers_hash = []; answer_ids = []; data.items.forEach(function(a) { a.comments = []; var id = +a.share_link.match(/\d+/); answer_ids.push(id); answers_hash[id] = a; }); if (!data.has_more) more_answers = false; comment_page = 1; getComments(); } }); } function getComments() { jQuery.ajax({ url: commentUrl(comment_page++, answer_ids), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { data.items.forEach(function(c) { if (c.owner.user_id === OVERRIDE_USER) answers_hash[c.post_id].comments.push(c); }); if (data.has_more) getComments(); else if (more_answers) getAnswers(); else process(); } }); } getAnswers(); var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/; var OVERRIDE_REG = /^Override\s*header:\s*/i; function getAuthorName(a) { return a.owner.display_name; } function process() { var valid = []; answers.forEach(function(a) { var body = a.body; a.comments.forEach(function(c) { if(OVERRIDE_REG.test(c.body)) body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>'; }); var match = body.match(SCORE_REG); if (match) valid.push({ user: getAuthorName(a), size: +match[2], language: match[1], link: a.share_link, }); else console.log(body); }); valid.sort(function (a, b) { var aB = a.size, bB = b.size; return aB - bB }); var languages = {}; var place = 1; var lastSize = null; var lastPlace = 1; valid.forEach(function (a) { if (a.size != lastSize) lastPlace = place; lastSize = a.size; ++place; var answer = jQuery("#answer-template").html(); answer = answer.replace("{{PLACE}}", lastPlace + ".") .replace("{{NAME}}", a.user) .replace("{{LANGUAGE}}", a.language) .replace("{{SIZE}}", a.size) .replace("{{LINK}}", a.link); answer = jQuery(answer); jQuery("#answers").append(answer); var lang = a.language; lang = jQuery('<a>'+lang+'</a>').text(); languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang.toLowerCase(), user: a.user, size: a.size, link: a.link}; }); var langs = []; for (var lang in languages) if (languages.hasOwnProperty(lang)) langs.push(languages[lang]); langs.sort(function (a, b) { if (a.lang_raw > b.lang_raw) return 1; if (a.lang_raw < b.lang_raw) return -1; return 0; }); for (var i = 0; i < langs.length; ++i) { var language = jQuery("#language-template").html(); var lang = langs[i]; language = language.replace("{{LANGUAGE}}", lang.lang) .replace("{{NAME}}", lang.user) .replace("{{SIZE}}", lang.size) .replace("{{LINK}}", lang.link); language = jQuery(language); jQuery("#languages").append(language); } }</script>
```
[Answer]
## C, ~~78~~ ~~52~~ ~~39~~ ~~34~~ 33 bytes
Even more C magic (thanks xsot):
```
c(n){return!n?:(4+6./~n)*c(n-1);}
```
`?:` [is a GNU extension](https://stackoverflow.com/a/2806311).
---
This time by expanding the recurrence below (thanks xnor and Thomas Kwa):
$$
\begin{equation}
\begin{split}
C\_0 & = 1 \\
C\_n & = \frac{2 (2n - 1)}{n + 1} C\_{n - 1} \\
& = \frac{2 (2n+2-3)}{n+1} C\_{n - 1} \\
& = 2 \left(2\frac{n+1}{n+1} - \frac{3}{n+1}\right) C\_{n - 1} \\
& = \left(4 - \frac{6}{n+1}\right) C\_{n - 1}
\end{split}
\end{equation}
$$
```
c(n){return n?(4+6./~n)*c(n-1):1;}
```
`-(n+1)` is replaced by `~n`, which is equivalent in two's complement and saves 4 bytes.
---
Again as a function, but this time exploiting the following recurrence:
$$
\begin{equation}
\begin{split}
C\_0 & = 1 \\
C\_n & = \frac{2 (2n - 1)}{n + 1} \cdot C\_{n - 1}
\end{split}
\end{equation}
$$
```
c(n){return n?2.*(2*n++-1)/n*c(n-2):1;}
```
`c(n)` enters an infinite recursion for negative `n`, although it's not relevant for this challenge.
---
Since calling a function seems an acceptable alternative to console I/O:
```
c(n){double c=1,k=2;while(k<=n)c*=1+n/k++;return c;}
```
`c(n)` takes an `int` and returns an `int`.
---
Original entry:
```
main(n){scanf("%d",&n);double c=1,k=2;while(k<=n)c*=1+n/k++;printf("%.0f",c);}
```
Instead of directly calculating the definition, the formula is rewritten as:
$$
\begin{equation}
\begin{split}
\frac{1}{n + 1} {2n \choose n} &= \frac{(2n)!}{(n!)^2 \cdot (n + 1)} \\
& = \frac{2n \cdot \ldots \cdot (n + 1)}{n! \cdot (n + 1)} \\
& = \frac{1}{n + 1} \cdot \frac{\prod\_{k = 1}^n (n + k)}{\prod\_{k = 1}^n k} \\
& = \frac{1}{n + 1} \cdot \prod\_{k = 1}^n \frac{n + k}{k} \\
& = \frac{1}{n + 1} \cdot \prod\_{k = 1}^n \left(1 + \frac{n}{k}\right) \\
& = \frac{1}{n + 1} (n + 1) \prod\_{k = 2}^n \left(1 + \frac{n}{k}\right) \\
& = \prod\_{k = 2}^n \left(1 + \frac{n}{k}\right)
\end{split}
\end{equation}
$$
The formula assumes `n >= 2`, but the code accounts for `n = 0` and `n = 1` too.
In the C mess above, `n` and `k` have the same role as in the formula, while `c` accumulates the product. All calculations are performed in floating point using `double`, which is almost always a bad idea, but in this case the results are correct up to `n = 19` at least, so it's ok.
`float` would have saved 1 byte, unfortunately it's not precise enough.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 4 bytes
```
Ḥc÷‘
```
[Try it online!](http://jelly.tryitonline.net/#code=4bikY8O34oCY&input=&args=NQ)
### How it works
```
Ḥc÷‘ Left argument: z
Ḥ Compute 2z.
c Hook; apply combinations to 2z and z.
÷‘ Divide the result by z+1.
```
[Answer]
## TI-BASIC, 11 bytes
```
(2Ans) nCr Ans/(Ans+1
```
Strangely, nCr has higher precedence than multiplication.
[Answer]
## CJam, 12 bytes
```
ri_2,*e!,\)/
```
[Try it online.](http://cjam.tryitonline.net/#code=cmlfMiwqZSEsXCkv&input=OA)
Beyond input 11, you'll need to tell your Java VM to use more memory. And I wouldn't actually recommend going much beyond 11. In theory, it works for any N though, since CJam uses arbitrary-precision integers.
### Explanation
CJam doesn't have a built-in for binomial coefficients, and computing them from three factorials takes a lot of bytes... so we'll have to do something better than that. :)
```
ri e# Read input and convert it to integer N.
_ e# Duplicate.
2, e# Push [0 1].
* e# Repeat this N times, giving [0 1 0 1 ... 0 1] with N zeros and N ones.
e! e# Compute the _distinct_ permutations of this array.
, e# Get the number of permutations - the binomial. There happen to be 2n-over-n of
e# of them. (Since 2n-over-n is the number of ways to choose n elements out of 2n, and
e# and here we're choosing n positions in a 2n-element array to place the zeros in.)
\ e# Swap with N.
)/ e# Increment and divide the binomial coefficient by N+1.
```
[Answer]
## Python 3, 33 bytes
```
f=lambda n:0**n or(4+6/~n)*f(n-1)
```
Uses the recurrence
```
f(0) = 1
f(n) = (4-6/(n+1)) * f(n-1)
```
The base case of 0 is handled as `0**n or`, which stops as `1` when `n==0` and otherwise evaluates the recursive expression on the right. The bitwise operator `~n==-n-1` shortens the denominator and saves on parens.
Python 3 is used for its float division. Python 2 could do the same with one more byte to write `6.`.
[Answer]
# Mathematica, ~~16~~ 13 bytes
```
CatalanNumber
```
Built-ins, amirite fellas :/
Non-builtin version (21 bytes):
```
Binomial[2#,#]/(#+1)&
```
A binomial-less version (25 bytes):
```
Product[(#+k)/k,{k,2,#}]&
```
[Answer]
## J, 8 bytes
```
>:%~]!+:
```
This is a monadic train; it uses the (2x nCr x)/(x+1) formula. Try it [here](https://a296a8f7c5110b2ece73921ddc2abbaaa3c90d10.googledrive.com/host/0B3cbLoy-_9Dbb0NaSk9MRGE5UEU/index.html#code=(%3E%3A%25%7E%5D!%2B%3A)5).
[Answer]
# pl, 4 bytes
```
☼ç▲÷
```
[Try it online.](http://pl.tryitonline.net/#code=4pi8w6filrLDtw&input=NQ)
## Explanation
In pl, functions take their arguments off the stack and push the result back onto the stack. Normally when there are not enough arguments on the stack, the function simply fails silently. However, something special happens when the amount of arguments on the stack is one off from the arity of the function -- the input variable `_` is added to the argument list:
```
☼ç▲÷
‚òº double: takes _ as the argument since there is nothing on the stack
ç combinations: since there is only one item on the stack (and arity is 2), it adds _ to the argument list (combinations(2_,_))
‚ñ≤ increment last used var (_)
√∑ divide: adds _ to the argument list again
```
In effect, this is the pseudocode:
```
divide(combinations(double(_),_),_+1);
```
[Answer]
# [Sesos](https://github.com/DennisMitchell/sesos), ~~94~~ ~~86~~ 68 bytes
8 bytes by changing the factorial-er from version 1 to version 2.
18 bytes by computing `n!(n+1)!` in one step. **Largely inspired by [Dennis' primality test algorithm](https://codegolf.stackexchange.com/a/86501/48934).**
Hexdump:
```
0000000: 16f8de a59f17 a0ebba 7f4cd3 e05f3f cf0fd0 a0ebde ..........L.._?......
0000015: b1c1bb 76fe18 8cc1bb 76fe1c e0fbda 390fda bde3d8 ...v.....v.....9.....
000002a: 000fbe af9d1b b47bc7 cfc11c b47bc7 cff1fa e07bda .......{.....{.....{.
000003f: 39e83e cf07 9.>..
```
[Try it online!](http://sesos.tryitonline.net/#code=c2V0IG51bWluCnNldCBudW1vdXQKZ2V0CmptcCxzdWIgMSxmd2QgMSxhZGQgMSxmd2QgMixhZGQgMixyd2QgMyxqbnoKZndkIDEsYWRkIDEKam1wCiAgam1wLHN1YiAxLHJ3ZCAxLGFkZCAxLHJ3ZCAxLGFkZCAxLHJ3ZCAxLGFkZCAxLGZ3ZCAzLGpuegogIHJ3ZCAxLHN1YiAxLHJ3ZCAxLHN1YiAxLHJ3ZCAxCiAgam1wLHN1YiAxLGZ3ZCAzLGFkZCAxLHJ3ZCAzLGpuegogIGZ3ZCAxCmpuegpmd2QgMwpqbXAKICBqbXAKICAgIHN1YiAxLHJ3ZCAxCiAgICBqbXAsc3ViIDEscndkIDEsYWRkIDEscndkIDEsYWRkIDEsZndkIDIsam56CiAgICByd2QgMgogICAgam1wLHN1YiAxLGZ3ZCAyLGFkZCAxLHJ3ZCAyLGpuegogICAgZndkIDMKICBqbnoKICByd2QgMQogIGptcCxzdWIgMSxqbnoKICByd2QgMQogIGptcCxzdWIgMSxmd2QgMixhZGQgMSxyd2QgMixqbnoKICBmd2QgMwpqbnogCmZ3ZCAxCmptcAogIGptcCxzdWIgMSxmd2QgMSxhZGQgMSxmd2QgMSxhZGQgMSxyd2QgMixqbnoKICBmd2QgMSxzdWIgMSxmd2QgMQogIGptcCxzdWIgMSxyd2QgMixhZGQgMSxmd2QgMixqbnoKICByd2QgMQpqbnoKcndkIDIKam1wCiAgam1wCiAgICBzdWIgMSxmd2QgMQogICAgam1wLHN1YiAxLGZ3ZCAxLGFkZCAxLGZ3ZCAxLGFkZCAxLHJ3ZCAyLGpuegogICAgZndkIDIKICAgIGptcCxzdWIgMSxyd2QgMixhZGQgMSxmd2QgMixqbnoKICAgIHJ3ZCAzCiAgam56CiAgZndkIDEKICBqbXAsc3ViIDEsam56CiAgZndkIDEKICBqbXAsc3ViIDEscndkIDIsYWRkIDEsZndkIDIsam56CiAgcndkIDMKam56IApmd2QgMQpqbXAKICBmd2QgMSxhZGQgMSxyd2QgMwogIGptcCxzdWIgMSxmd2QgMSxhZGQgMSxmd2QgMSxzdWIgMSxyd2QgMixqbnoKICBmd2QgMQogIGptcCxzdWIgMSxyd2QgMSxhZGQgMSxmd2QgMSxqbnoKICBmd2QgMQpqbnoKZndkIDEKcHV0&input=NA&debug=on)
Uses the formula `a(n) = (2n)! / (n!(n+1)!)`.
* The factorial-er: [version 1](http://sesos.tryitonline.net/#code=c2V0IG51bWluCnNldCBudW1vdXQKZ2V0CmptcCxzdWIgMSxmd2QgMSxhZGQgMSxmd2QgMSxhZGQgMSxyd2QgMixqbnoKZndkIDMKYWRkIDEKcndkIDIKam1wCiAgc3ViIDEKICBmd2QgMQogIGptcAogICAgc3ViIDEKICAgIGZ3ZCAxCiAgICBqbXAKICAgICAgc3ViIDEsZndkIDEsYWRkIDEsZndkIDEsYWRkIDEscndkIDIKICAgIGpuegogICAgZndkIDEKICAgIGptcAogICAgICBzdWIgMSxyd2QgMSxhZGQgMSxmd2QgMQogICAgam56CiAgICByd2QgMgogIGpuegogIGZ3ZCAxLGptcCxzdWIgMSxqbnoKICByd2QgMgogIGptcCxzdWIgMSxmd2QgMixhZGQgMSxyd2QgMixqbnoKICBmd2QgMgogIGptcCxzdWIgMSxyd2QgMSxhZGQgMSxyd2QgMSxhZGQgMSxmd2QgMixqbnoKICBmd2QgMgogIGptcCxzdWIgMSxyd2QgMixhZGQgMSxmd2QgMixqbnoKICByd2QgNApqbnoKZndkIDIKcHV0&input=NQ&debug=on) (in-place, constant memory), [version 2](http://sesos.tryitonline.net/#code=c2V0IG51bWluCnNldCBudW1vdXQKZ2V0CmptcAogIGptcCxzdWIgMSxmd2QgMixhZGQgMSxyd2QgMixqbnoKICBmd2QgMgogIGptcCxzdWIgMSxyd2QgMSxhZGQgMSxyd2QgMSxhZGQgMSxmd2QgMixqbnoKICByd2QgMQogIHN1YiAxCmpuegpyd2QgMgpqbXAKICBqbXAKICAgIHN1YiAxLGZ3ZCAxCiAgICBqbXAsc3ViIDEsZndkIDEsYWRkIDEsZndkIDEsYWRkIDEscndkIDIsam56CiAgICBmd2QgMQogICAgam1wLHN1YiAxLHJ3ZCAxLGFkZCAxLGZ3ZCAxLGpuegogICAgcndkIDIKICBqbnoKICBmd2QgMSxqbXAsc3ViIDEsam56LGZ3ZCAyCiAgam1wLHN1YiAxLHJ3ZCAzLGFkZCAxLGZ3ZCAzLGpuegogIHJ3ZCA0Cmpuegpmd2QgMQpwdXQ&input=NQ&debug=on) (in-place, linear memory)
* The multiplier: [here](http://sesos.tryitonline.net/#code=c2V0IG51bWluCnNldCBudW1vdXQKZ2V0CnJ3ZCAxCmdldApqbXAKICBzdWIgMQogIGZ3ZCAxCiAgam1wLHN1YiAxLGZ3ZCAxLGFkZCAxLGZ3ZCAxLGFkZCAxLHJ3ZCAyLGpuegogIGZ3ZCAxCiAgam1wLHN1YiAxLHJ3ZCAxLGFkZCAxLGZ3ZCAxLGpuegogIHJ3ZCAyCmpuegpmd2QgMwpwdXQ&input=MTIKMTM&debug=on) (in place, constant memory)
* The divider: [here](http://sesos.tryitonline.net/#code=c2V0IG51bWluCnNldCBudW1vdXQKZ2V0CmZ3ZCAyCmdldApyd2QgMgpqbXAKICBmd2QgMwogIGFkZCAxCiAgcndkIDEKICBqbXAsc3ViIDEscndkIDEsYWRkIDEscndkIDEsc3ViIDEsZndkIDIsam56CiAgcndkIDEKICBqbXAsc3ViIDEsZndkIDEsYWRkIDEscndkIDEsam56CiAgcndkIDEKam56CmZ3ZCAzCnB1dA&input=MTU2CjEy&debug=on) (does not halt if not divisible)
## Assembler
```
set numin
set numout
get
jmp,sub 1,fwd 1,add 1,fwd 2,add 2,rwd 3,jnz
fwd 1,add 1
jmp
jmp,sub 1,rwd 1,add 1,rwd 1,add 1,rwd 1,add 1,fwd 3,jnz
rwd 1,sub 1,rwd 1,sub 1,rwd 1
jmp,sub 1,fwd 3,add 1,rwd 3,jnz
fwd 1
jnz
fwd 3
jmp
jmp
sub 1,rwd 1
jmp,sub 1,rwd 1,add 1,rwd 1,add 1,fwd 2,jnz
rwd 2
jmp,sub 1,fwd 2,add 1,rwd 2,jnz
fwd 3
jnz
rwd 1
jmp,sub 1,jnz
rwd 1
jmp,sub 1,fwd 2,add 1,rwd 2,jnz
fwd 3
jnz
fwd 1
jmp
jmp,sub 1,fwd 1,add 1,fwd 1,add 1,rwd 2,jnz
fwd 1,sub 1,fwd 1
jmp,sub 1,rwd 2,add 1,fwd 2,jnz
rwd 1
jnz
rwd 2
jmp
jmp
sub 1,fwd 1
jmp,sub 1,fwd 1,add 1,fwd 1,add 1,rwd 2,jnz
fwd 2
jmp,sub 1,rwd 2,add 1,fwd 2,jnz
rwd 3
jnz
fwd 1
jmp,sub 1,jnz
fwd 1
jmp,sub 1,rwd 2,add 1,fwd 2,jnz
rwd 3
jnz
fwd 1
jmp
fwd 1,add 1,rwd 3
jmp,sub 1,fwd 1,add 1,fwd 1,sub 1,rwd 2,jnz
fwd 1
jmp,sub 1,rwd 1,add 1,fwd 1,jnz
fwd 1
jnz
fwd 1
put
```
## Brainfuck equivalent
[This Retina script](http://retina.tryitonline.net/#code=TSFgKFtmcl13ZHxhZGR8c3ViKSBcZHxqbnp8am1wfGpuZXxub3AKam1wClsKam56Cl0Kc3ViIChcZCkKJDEkKi0KYWRkIChcZCkKJDEkKisKZndkIChcZCkKJDEkKj4KcndkIChcZCkKJDEkKjwKwrYK&input=c2V0IG51bWluCnNldCBudW1vdXQKZ2V0CmptcCxzdWIgMSxmd2QgMSxhZGQgMSxmd2QgMixhZGQgMixyd2QgMyxqbnoKZndkIDEsYWRkIDEKam1wCiAgam1wLHN1YiAxLHJ3ZCAxLGFkZCAxLHJ3ZCAxLGFkZCAxLHJ3ZCAxLGFkZCAxLGZ3ZCAzLGpuegogIHJ3ZCAxLHN1YiAxLHJ3ZCAxLHN1YiAxLHJ3ZCAxCiAgam1wLHN1YiAxLGZ3ZCAzLGFkZCAxLHJ3ZCAzLGpuegogIGZ3ZCAxCmpuegpmd2QgMwpqbXAKICBqbXAKICAgIHN1YiAxLHJ3ZCAxCiAgICBqbXAsc3ViIDEscndkIDEsYWRkIDEscndkIDEsYWRkIDEsZndkIDIsam56CiAgICByd2QgMgogICAgam1wLHN1YiAxLGZ3ZCAyLGFkZCAxLHJ3ZCAyLGpuegogICAgZndkIDMKICBqbnoKICByd2QgMQogIGptcCxzdWIgMSxqbnoKICByd2QgMQogIGptcCxzdWIgMSxmd2QgMixhZGQgMSxyd2QgMixqbnoKICBmd2QgMwpqbnogCmZ3ZCAxCmptcAogIGptcCxzdWIgMSxmd2QgMSxhZGQgMSxmd2QgMSxhZGQgMSxyd2QgMixqbnoKICBmd2QgMSxzdWIgMSxmd2QgMQogIGptcCxzdWIgMSxyd2QgMixhZGQgMSxmd2QgMixqbnoKICByd2QgMQpqbnoKcndkIDIKam1wCiAgam1wCiAgICBzdWIgMSxmd2QgMQogICAgam1wLHN1YiAxLGZ3ZCAxLGFkZCAxLGZ3ZCAxLGFkZCAxLHJ3ZCAyLGpuegogICAgZndkIDIKICAgIGptcCxzdWIgMSxyd2QgMixhZGQgMSxmd2QgMixqbnoKICAgIHJ3ZCAzCiAgam56CiAgZndkIDEKICBqbXAsc3ViIDEsam56CiAgZndkIDEKICBqbXAsc3ViIDEscndkIDIsYWRkIDEsZndkIDIsam56CiAgcndkIDMKam56IApmd2QgMQpqbXAKICBmd2QgMSxhZGQgMSxyd2QgMwogIGptcCxzdWIgMSxmd2QgMSxhZGQgMSxmd2QgMSxzdWIgMSxyd2QgMixqbnoKICBmd2QgMQogIGptcCxzdWIgMSxyd2QgMSxhZGQgMSxmd2QgMSxqbnoKICBmd2QgMQpqbnoKZndkIDEKcHV0) is used to generate the brainfuck equivalent. Note that it only accepts one digit as command argument, and does not check if a command is in the comments.
```
[->+>>++<<<]>+
[[-<+<+<+>>>]<-<-<[->>>+<<<]>]>>>
[[-<[-<+<+>>]<<[->>+<<]>>>]<[-]<[->>+<<]>>>]>
[[->+>+<<]>->[-<<+>>]<]<<
[[->[->+>+<<]>>[-<<+>>]<<<]>[-]>[-<<+>>]<<<]>
[>+<<<[->+>-<<]>[-<+>]>]>
```
[Answer]
# Pyth, 8
```
/.cyQQhQ
```
[Try it online](http://pyth.herokuapp.com/?code=%2F.cyQQhQ&input=5&debug=0) or run the [Test Suite](http://pyth.herokuapp.com/?code=%2F.cyQQhQ&input=50&test_suite=1&test_suite_input=0%0A1%0A2%0A3%0A4%0A5%0A6%0A7%0A8%0A9%0A10%0A11%0A12%0A13%0A14%0A15%0A16%0A17%0A18%0A19&debug=0)
### Explanation
```
/.cyQQhQ ## implicit: Q = eval(input())
/ hQ ## integer division by (Q + 1)
.c ## nCr
yQ ## use Q * 2 as n
Q ## use Q as r
```
[Answer]
# Julia, 23 bytes
```
n->binomial(2n,n)/(n+1)
```
This is an anonymous function that accepts an integer and returns a float. It uses the basic binomial formula. To call it, give it a name, e.g. `f=n->...`.
[Answer]
## Seriously, 9 bytes
```
,;;u)τ╣E\
```
Hex Dump:
```
2c3b3b7529e7b9455c
```
[Try it online](http://seriouslylang.herokuapp.com/link/code=2c3b3b7529e7b9452f&input=5)
Explanation:
```
, Read in evaluated input n
;; Duplicate it twice
u) Increment n and rotate it to bottom of stack
τ╣ Double n, then push 2n-th row of Pascal's triangle
E Look-up nth element of the row, and so push 2nCn
\ Divide it by the n+1 below it.
```
[Answer]
# JavaScript (ES6), 24 bytes
Based on the [Python answer](https://codegolf.stackexchange.com/a/66141/42545).
```
c=x=>x?(4+6/~x)*c(x-1):1
```
### How it works
```
c=x=>x?(4+6/~x)*c(x-1):1
c=x=> // Define a function c that takes a parameter x and returns:
x? :1 // If x == 0, 1.
(4+6/~x) // Otherwise, (4 + (6 / (-x - 1)))
*c(x-1) // times the previous item in the sequence.
```
I think this is the shortest it can get, but suggestions are welcome!
[Answer]
## Matlab, ~~35~~ 25 bytes
```
@(n)nchoosek(2*n,n)/(n+1)
```
## Octave, 23 bytes
```
@(n)nchoosek(2*n,n++)/n
```
[Answer]
# ùîºùïäùïÑùïöùïü, 3 chars / 6 bytes
```
Мƅï
```
`[Try it here (Firefox only).](http://molarmanful.github.io/ESMin/interpreter.html?eval=true&input=4&code=%D0%9C%C6%85%C3%AF)`
Builtins ftw! So glad I implemented math.js early on.
# Bonus solution, 12 chars / 19 bytes
```
Мơ 2*ï,ï)/⧺ï
```
`[Try it here (Firefox only).](http://molarmanful.github.io/ESMin/interpreter2.html?eval=true&input=19&code=%D0%9C%C6%A1%202*%C3%AF%2C%C3%AF%29%2F%E2%A7%BA%C3%AF)`
Ay! 19th byte!
Evaluates to pseudo-ES6 as:
```
nchoosek(2*input,input)/(input+1)
```
[Answer]
## Haskell, 27 bytes
```
g 0=1
g n=(4-6/(n+1))*g(n-1)
```
A recursive formula. There's got to be a way to save on parens...
Directly taking the product was 2 bytes longer:
```
g n=product[4-6/i|i<-[2..n+1]]
```
[Answer]
## Dyalog APL, 9 bytes
```
+∘1÷⍨⊢!+⍨
```
This is a monadic train; it uses the (2x nCr x)/(x+1) formula. Try it online [here](http://tryapl.org/?a=%28+%u22181%F7%u2368%u22A2%21+%u2368%29%20%u237315&run).
[Answer]
# C, ~~122~~ ~~121~~ ~~119~~ 108 bytes
```
main(j,v)char**v;{long long p=1,i,n=atoi(v[1]);for(j=0,i=n+1;i<2*n;p=(p*++i)/++j);p=n?p/n:p;printf("%d",p);}
```
I used gcc (GCC) 3.4.4 (cygming special, gdc 0.12, using dmd 0.125) to compile in a windows cygwin environment. Input comes in on the command line. It's similar to Sherlock9's Python solution but the loops are combined into one to avoid overflow and get output up to the 20th Catalan number (n=19).
[Answer]
# [Javagony](http://esolangs.org/wiki/Javagony), 223 bytes
```
public class C{public static int f(int a,int b){try{int z=1/(b-a);}catch(Exception e){return 1;}return a*f(a+1,b);}public static void main(String[]s){int m=Integer.parseInt(s[0])+1;System.out.println(f(m,2*m-1)/f(1,m)/m);}}
```
Fully expanded:
```
public class C {
public static int f(int a,int b){
try {
int z=1/(b-a);
} catch (Exception e){
return 1;
}
return a*f(a+1,b);
}
public static void main(String[] s){
int m=Integer.parseInt(s[0])+1;
System.out.println(f(m,2*m-1)/f(1,m)/m);
}
}
```
[Answer]
# R, ~~35~~ ~~28~~ 16 bytes
```
numbers::catalan
```
Edit: Use numbers package builtin.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 6 bytes
```
Dxcr>/
```
**Explanation:**
```
Code: Stack: Explanation:
Dxcr>/
D [n, n] # Duplicate of the stack. Since it's empty, input is used.
x [n, n, 2n] # Pops a, pushes a, a * 2
c [n, n nCr 2n] # Pops a,b pushes a nCr b
r [n nCr 2n, n] # Reverses the stack
> [n nCr 2n, n + 1] # Increment on the last item
/ [(n nCr 2n)/(n + 1)] # Divides the last two items
# Implicit, nothing has printed, so we print the last item
```
[Answer]
# R, 28 bytes
Not using a package, so slightly longer than a previous answer
```
choose(2*(n=scan()),n)/(n+1)
```
[Answer]
# [Oasis](http://github.com/Adriandmen/Oasis), 9 bytes
```
nxx¬´*n>√∑1
```
[Try it online!](http://oasis.tryitonline.net/#code=bnh4wqsqbj7DtzE&input=&args=MTk)
Oasis is a language designed by [Adnan](https://codegolf.stackexchange.com/users/34388/adnan) which is specialized in sequences.
Here, we shall use the following relationship kindly provided by [Stefano Sanfilippo](https://codegolf.stackexchange.com/a/66168/48934):
Currently, this language can do recursion and closed form.
To specify that `a(0)=1` is simple: just add the `1` at the end.
For example, if a sequence begins with `a(0)=0` and `a(1)=1`, just put `10` at the end.
Unfortunately, all sequences must be 0-indexed.
```
nxx¬´*n>√∑1 stack
1 a(0)=1
n push n (input) n
x double 2n
x double 4n
¬´ minus 2 4n-2
* multiply: second (4n-2)*a(n-1)
argument is missing,
so a(n-1) is used.
n push n (input) (4n-2)*a(n-1) n
> add 1 (4n-2)*a(n-1) n+1
√∑ integer division (4n-2)*a(n-1)/(n+1)
= ((4n-2)/(n+1))*a(n-1)
= ((4n+4-6)/(n+1))*a(n-1)
= ((4n+4)/(n+1) - 6/(n+1))*a(n-1)
= (4-6/(n+1))*a(n-1)
```
---
Closed-form:
## 10 bytes
```
nx!n!n>!*√∑
```
[Try it online!](http://oasis.tryitonline.net/#code=bnghbiFuPiEqw7c&input=&args=MTk)
```
nx!n!n>!*√∑
n push n (input)
x double
! factorial: stack is now [(2n)!]
n push n (input)
! factorial: stack is now [(2n)! n!]
n push n (input)
> add 1
! factorial: stack is now [(2n)! n! (n+1)!]
* multiply: stack is now [(2n)! (n!(n+1)!)]
√∑ divide: stack is now [(2n)!/(n!(n+1)!)]
```
[Answer]
# TeX, 231 bytes
```
\newcommand{\f}[1]{\begingroup\count0=1\count1=2\count2=2\count3=0\loop\multiply\count0 by\the\count1\divide\count0 by\the\count2\advance\count1 by4\advance\count2 by1\advance\count3 by1
\ifnum\count3<#1\repeat\the\count0\endgroup}
```
## Usage
```
\documentclass[12pt,a4paper]{article}
\begin{document}
\newcommand{\f}[1]{\begingroup\count0=1\count1=2\count2=2\count3=0\loop\multiply\count0 by\the\count1\divide\count0 by\the\count2\advance\count1 by4\advance\count2 by1\advance\count3 by1
\ifnum\count3<#1\repeat\the\count0\endgroup}
\newcount \i
\i = 0
\loop
\f{\the\i}
\advance \i by 1
\ifnum \i < 15 \repeat
\end{document}
```
[](https://i.stack.imgur.com/Wckg8.png)
[Answer]
# Japt, 16 bytes
Even Mathematica is shorter. `:-/`
```
U*2ª1 o àU l /°U
```
[Try it online!](http://ethproductions.github.io/japt?v=master&code=VSoyqjEgbyDgVSBsIC+wVQ==&input=Ng==)
### Ungolfed and explanation
```
U*2ª 1 o àU l /° U
U*2||1 o àU l /++U
// Implicit: U = input number
U*2||1 // Take U*2. If it is zero, take 1.
o àU // Generate a range of this length, and calculate all combinations of length U.
l /++U // Take the length of the result and divide by (U+1).
// Implicit: output result
```
Alternate version, based on the recursive formula:
```
C=_?(4+6/~Z *C$(Z-1):1};$C(U
```
[Answer]
# [Vitsy](https://github.com/VTCAKAVSMoACE/Vitsy), 13 Bytes
```
VV2*FVF/V1+F/
V Capture the input as a final global variable.
V Push it back.
2* Multiply it by 2
F Factorial.
VF Factorial of the input.
/ Divide the second to top by the first.
V1+ 1+input
F Factorial.
/ Divide.
```
This is a function in [Vitsy](https://github.com/VTCAKAVSMoACE/Vitsy). How to make it a program that does this, you ask? Concatenate `N`. c:
[Try it online!](http://vitsy.tryitonline.net/#code=VlYyKkZWRi9WMStGL04&input=&args=MQ)
[Answer]
# [Milky Way 1.5.14](https://github.com/zachgates7/Milky-Way), 14 bytes
```
':2K;*Ny;1+/A!
```
---
### Explanation
```
' # read input from the command line
: # duplicate the TOS
2 1 # push integer to the stack
K # push a Pythonic range(0, TOS) as a list
; ; # swap the TOS and the STOS
* # multiply the TOS and STOS
N # push a list of the permutations of the TOS (for lists)
y # push the length of the TOS
+ # add the STOS to the TOS
/ # divide the TOS by the STOS
A # push the integer representation of the TOS
! # output the TOS
```
or, alternatively, the *much* more efficient version:
---
# [Milky Way 1.5.14](https://github.com/zachgates7/Milky-Way), 22 bytes
```
'1%{;K£1+k1-6;/4+*}A!
```
---
### Explanation
```
' # read input from the command line
1 1 1 6 4 # push integer to the stack
%{ £ } # for loop
; ; # swap the TOS and the STOS
K # push a Pythonic range(0, TOS) as a list
+ + # add the TOS and STOS
k # push the negative absolute value of the TOS
- # subtract the STOS from the TOS
/ # divide the TOS by the STOS
* # multiply the TOS and the STOS
A # push the integer representation of the TOS
! # output the TOS
```
---
## Usage
```
python3 milkyway.py <path-to-code> -i <input-integer>
```
[Answer]
# Clojure/ClojureScript, 53 bytes
```
(defn c[x](if(= 0 x)1(*(c(dec x))(- 4(/ 6(inc x))))))
```
Clojure can be pretty frustrating to golf in. It's very pithy while still being very readable, but some of the niftier features are really verbose. `(inc x)` is more idiomatic than `(+ x 1)` and "feels" more concise, but doesn't actually save characters. And writing chains of operations is nicer as `(->> x inc (/ 6) (- 4))`, but it's actually longer than just doing it the ugly way.
[Answer]
# Ruby, 30 bytes
```
c=->n{n<1?1:c[n-1]*(4+6.0/~n)}
```
Thanks to xsot, saved few bytes by using complement.
**Ungolfed:**
```
c = -> n {
n < 1 ? 1 : c[n-1]*(4+6.0/~n)
}
```
**Usage:**
```
> c=->n{n<1?1:c[n-1]*(4+6.0/~n)}
> c[10]
=> 16796.0
```
[Answer]
# Prolog, 42 bytes
Using recursion is almost always the way to go with Prolog.
**Code:**
```
0*1.
N*X:-M is N-1,M*Y,X is(4-6/(N+1))*Y.
```
**Example:**
```
19*X.
X = 1767263190.0
```
Try it online [here](http://swish.swi-prolog.org/p/qICyHIzl.pl)
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/219787/edit).
Closed 2 years ago.
[Improve this question](/posts/219787/edit)
A "qruine" if you will :)
Design a QR code that legibly spells with its pixels (or the space between them) the text that it scans to.
For example, this QR code scans to the letter A, and also spells out A in white:
[](https://i.stack.imgur.com/uD18h.png)
There are 4 categories, one for each mode of QR code: numeric, alphanumeric, byte, and kanji. Please state which category your submission is for.
In order to prevent trivial solutions like "------------", in all categories except numeric mode the text must be coherent in a natural language. (In numeric mode the winner will be a large number of 1s, obviously.)
Your score is 2*l* ÷ *h*, where *l* is the length of the text and *h* is the width of the QR code in QR dots (not necessarily the same as screen pixels). Highest score in each category wins. The score of the sample QR code is (2\*1 character / 97 dots wide) = 0.02.
]
|
[Question]
[
**Challenge**
I've checked that there is a question [Compute the Discrete Cosine Transform](https://codegolf.stackexchange.com/q/120325/100303) which is a competition for implementing a shortest solution to compute the one dimensional discrete cosine transform.
The goal of this challenge is to implement a program to calculate three dimensional discrete cosine transform which makes processing time as short as possible.
The formula of 3D Discrete Cosine Transform is as below.
[](https://i.stack.imgur.com/eBSFf.png)
Considering the different size case in three dimension.
[](https://i.stack.imgur.com/Zq2fb.png)
About the accuracy requirement in this challenge, you need to perform the calculation based on double precision floating point.
**Example Input / Output for Performance Evaluation**
Because it is 3D numerical data input / output in this challenge, the structure of input / output data in example is as below.
1. N = 8 :
```
x(0, 0, 0) x(0, 0, 1) x(0, 0, 2) x(0, 0, 3) x(0, 0, 4) x(0, 0, 5) x(0, 0, 6) x(0, 0, 7)
x(0, 1, 0) x(0, 1, 1) x(0, 1, 2) x(0, 1, 3) x(0, 1, 4) x(0, 1, 5) x(0, 1, 6) x(0, 1, 7)
...
x(0, 7, 0) x(0, 7, 1) x(0, 7, 2) x(0, 7, 3) x(0, 7, 4) x(0, 7, 5) x(0, 7, 6) x(0, 7, 7)
x(1, 0, 0) x(1, 0, 1) x(1, 0, 2) x(1, 0, 3) x(1, 0, 4) x(1, 0, 5) x(1, 0, 6) x(1, 0, 7)
x(1, 1, 0) x(1, 1, 1) x(1, 1, 2) x(1, 1, 3) x(1, 1, 4) x(1, 1, 5) x(1, 1, 6) x(1, 1, 7)
...
x(1, 7, 0) x(1, 7, 1) x(1, 7, 2) x(1, 7, 3) x(1, 7, 4) x(1, 7, 5) x(1, 7, 6) x(1, 7, 7)
x(7, 0, 0) x(7, 0, 1) x(7, 0, 2) x(7, 0, 3) x(7, 0, 4) x(7, 0, 5) x(7, 0, 6) x(7, 0, 7)
x(7, 1, 0) x(7, 1, 1) x(7, 1, 2) x(7, 1, 3) x(7, 1, 4) x(7, 1, 5) x(7, 1, 6) x(7, 1, 7)
...
x(7, 7, 0) x(7, 7, 1) x(7, 7, 2) x(7, 7, 3) x(7, 7, 4) x(7, 7, 5) x(7, 7, 6) x(7, 7, 7)
```
```
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
255 255 255 255 255 255 255 255
255 255 255 255 255 255 255 255
255 255 255 255 255 255 255 255
255 255 255 255 255 255 255 255
255 255 255 255 255 255 255 255
255 255 255 255 255 255 255 255
255 255 255 255 255 255 255 255
255 255 255 255 255 255 255 255
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
255 255 255 255 255 255 255 255
255 255 255 255 255 255 255 255
255 255 255 255 255 255 255 255
255 255 255 255 255 255 255 255
255 255 255 255 255 255 255 255
255 255 255 255 255 255 255 255
255 255 255 255 255 255 255 255
255 255 255 255 255 255 255 255
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
255 255 255 255 255 255 255 255
255 255 255 255 255 255 255 255
255 255 255 255 255 255 255 255
255 255 255 255 255 255 255 255
255 255 255 255 255 255 255 255
255 255 255 255 255 255 255 255
255 255 255 255 255 255 255 255
255 255 255 255 255 255 255 255
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
255 255 255 255 255 255 255 255
255 255 255 255 255 255 255 255
255 255 255 255 255 255 255 255
255 255 255 255 255 255 255 255
255 255 255 255 255 255 255 255
255 255 255 255 255 255 255 255
255 255 255 255 255 255 255 255
255 255 255 255 255 255 255 255
```
```
360.624 2.81997e-14 -2.88658e-14 4.24105e-14 1.42109e-14 -2.84217e-14 -2.77001e-13 4.26437e-13
3.10862e-15 3.14018e-16 6.28037e-16 2.51215e-15 0 -1.25607e-15 1.57009e-16 -1.17757e-15
-1.46549e-14 9.42055e-15 -3.14018e-16 2.19813e-15 -2.19813e-15 -3.14018e-16 1.25607e-15 1.17757e-15
7.10543e-14 -9.42055e-16 5.0243e-15 -3.14018e-16 0 2.51215e-15 2.51215e-15 1.25607e-15
2.13163e-14 6.28037e-16 -5.0243e-15 0 -2.51215e-15 -1.09906e-15 0 -1.41308e-15
-5.01821e-14 -5.65233e-15 4.71028e-15 2.82617e-15 -1.57009e-16 -5.0243e-15 1.17757e-15 -1.13832e-15
-2.6934e-13 -4.39626e-15 5.49532e-15 1.57009e-16 0 1.09906e-15 2.51215e-15 -1.25607e-15
4.39315e-13 1.33458e-15 9.42055e-16 2.51215e-15 -1.02056e-15 -1.41308e-15 -2.74766e-16 -3.76822e-15
-64.9989 -7.22243e-15 8.79252e-15 -2.51215e-15 -1.25607e-15 5.65233e-15 5.66803e-14 -7.87401e-14
-6.28037e-15 -3.55271e-15 -8.88178e-16 8.88178e-16 8.88178e-16 -8.88178e-16 -1.33227e-15 -6.66134e-16
3.51701e-14 1.77636e-15 4.44089e-16 -2.66454e-15 4.44089e-16 8.88178e-16 2.22045e-16 3.33067e-16
2.07252e-14 0 -4.44089e-15 2.22045e-15 4.44089e-16 0 -1.77636e-15 0
0 1.77636e-15 1.33227e-15 1.33227e-15 -8.88178e-16 -2.22045e-16 -1.33227e-15 4.44089e-16
1.00486e-14 1.77636e-15 -8.88178e-16 1.33227e-15 -1.11022e-15 2.22045e-16 0 -7.21645e-16
5.80934e-14 -1.33227e-15 -1.77636e-15 -1.9984e-15 0 -1.11022e-16 -9.99201e-16 8.32667e-16
-7.96037e-14 1.33227e-15 3.33067e-15 -7.77156e-16 1.11022e-16 4.44089e-16 1.38778e-15 -9.71445e-16
-4.74731e-13 -6.28037e-16 3.14018e-16 4.71028e-15 -3.76822e-15 -3.76822e-15 3.14018e-15 3.68972e-15
-4.52187e-14 3.55271e-15 8.88178e-16 -4.44089e-16 -8.88178e-16 0 0 -3.33067e-16
4.39626e-15 4.88498e-15 -1.33227e-15 8.88178e-16 0 2.22045e-16 -4.44089e-16 -1.88738e-15
8.16448e-15 1.77636e-15 -1.77636e-15 8.88178e-16 -8.88178e-16 1.77636e-15 -2.22045e-16 7.77156e-16
6.28037e-16 -1.77636e-15 -1.33227e-15 0 0 -8.88178e-16 -1.44329e-15 1.88738e-15
-1.25607e-14 -8.88178e-16 3.77476e-15 1.9984e-15 -6.66134e-16 4.44089e-16 2.22045e-15 7.21645e-16
1.57009e-15 4.88498e-15 -2.22045e-16 1.33227e-15 -9.99201e-16 3.33067e-16 -1.44329e-15 -2.22045e-16
4.71028e-16 4.21885e-15 6.66134e-16 3.33067e-16 1.66533e-15 -5.55112e-17 2.77556e-16 -6.93889e-16
-76.6715 2.82617e-15 1.19327e-14 -5.96635e-15 -3.76822e-15 6.90841e-15 5.95065e-14 -8.98093e-14
-3.14018e-14 2.22045e-15 -1.33227e-15 -4.44089e-16 0 8.88178e-16 -2.22045e-16 6.66134e-16
2.51215e-14 -4.44089e-16 1.77636e-15 4.44089e-16 0 6.66134e-16 -2.22045e-16 -5.55112e-16
-3.57981e-14 4.44089e-16 -2.66454e-15 -4.44089e-16 8.88178e-16 0 -1.55431e-15 0
-8.16448e-15 1.33227e-15 0 1.55431e-15 1.55431e-15 -8.88178e-16 -4.44089e-16 -4.44089e-16
1.31888e-14 3.10862e-15 -1.11022e-15 -8.88178e-16 6.66134e-16 1.77636e-15 5.55112e-16 -1.4988e-15
5.68373e-14 0 4.66294e-15 -1.9984e-15 1.11022e-16 2.22045e-16 7.21645e-16 6.10623e-16
-8.79252e-14 -2.22045e-16 7.77156e-16 9.99201e-16 -5.55112e-16 -1.11022e-15 1.83187e-15 -1.05471e-15
-4.9738e-14 8.79252e-15 -6.90841e-15 -2.82617e-15 -5.0243e-15 2.35514e-15 -2.51215e-15 -1.57009e-16
-5.0243e-15 -3.55271e-15 -8.88178e-16 4.44089e-16 -8.88178e-16 -2.22045e-16 6.66134e-16 1.11022e-15
-1.7585e-14 -5.77316e-15 4.44089e-16 -2.66454e-15 2.22045e-16 -6.66134e-16 3.33067e-16 8.88178e-16
-5.65233e-15 3.55271e-15 -1.33227e-15 -4.44089e-16 -2.22045e-16 -4.44089e-16 0 -2.22045e-16
-1.00486e-14 -2.22045e-15 1.9984e-15 2.22045e-16 0 0 0 -2.22045e-16
3.14018e-16 -2.22045e-16 -8.88178e-16 -6.66134e-16 4.44089e-16 4.44089e-16 2.10942e-15 3.88578e-16
2.82617e-15 -3.55271e-15 1.77636e-15 1.22125e-15 2.22045e-16 7.77156e-16 1.88738e-15 1.05471e-15
2.51215e-15 1.9984e-15 2.10942e-15 -1.4988e-15 -9.99201e-16 5.55112e-17 1.11022e-15 2.77556e-16
-114.747 -3.14018e-14 1.22467e-14 -8.16448e-15 -6.90841e-15 1.00486e-14 8.81607e-14 -1.39149e-13
-5.0243e-15 -4.44089e-15 0 4.44089e-16 -4.44089e-16 0 -1.22125e-15 -4.996e-16
-2.51215e-15 5.32907e-15 -8.88178e-16 -1.9984e-15 4.44089e-16 2.22045e-15 -5.55112e-16 -1.66533e-16
1.57009e-14 2.22045e-16 -4.44089e-16 1.77636e-15 -8.88178e-16 -8.88178e-16 1.11022e-16 -6.10623e-16
-3.76822e-15 1.77636e-15 -6.66134e-16 0 0 2.22045e-16 -1.66533e-15 4.996e-16
8.4785e-15 3.77476e-15 6.66134e-16 -1.33227e-15 -1.11022e-16 -8.88178e-16 -1.11022e-16 9.71445e-16
9.02803e-14 7.21645e-15 -6.66134e-16 -7.77156e-16 1.11022e-16 1.05471e-15 -1.94289e-15 -4.16334e-16
-1.42957e-13 2.72005e-15 6.10623e-16 -1.66533e-16 7.77156e-16 1.05471e-15 2.77556e-16 1.84575e-15
-1.00209e-12 6.28037e-16 1.57009e-16 1.25607e-15 1.25607e-15 3.76822e-15 0 -3.76822e-15
1.41308e-14 -3.77476e-15 -2.44249e-15 0 4.44089e-16 -7.77156e-16 -6.66134e-16 9.4369e-16
6.59439e-15 6.66134e-16 -1.11022e-15 -1.33227e-15 4.44089e-16 -1.44329e-15 -5.55112e-16 -8.88178e-16
9.10654e-15 -6.21725e-15 6.66134e-16 -2.22045e-16 4.44089e-16 3.33067e-16 -1.11022e-16 -4.996e-16
3.14018e-16 2.22045e-15 4.44089e-16 -6.66134e-16 3.33067e-16 -7.77156e-16 3.88578e-16 1.02696e-15
1.25607e-15 3.10862e-15 5.55112e-16 -4.44089e-16 -5.55112e-16 -1.27676e-15 9.99201e-16 -1.08247e-15
2.35514e-15 2.77556e-15 -1.22125e-15 2.22045e-16 1.38778e-15 6.10623e-16 1.22125e-15 -1.95677e-15
-1.31888e-14 2.9976e-15 1.27676e-15 -3.05311e-16 1.08247e-15 -5.82867e-16 -1.26288e-15 5.34295e-16
-326.772 -3.41495e-14 3.26579e-14 -3.51701e-14 -1.31888e-14 2.51215e-14 2.49174e-13 -3.90796e-13
-3.18729e-14 -2.66454e-15 -3.21965e-15 -7.77156e-16 -8.88178e-16 8.32667e-16 -1.27676e-15 -1.08247e-15
5.85644e-14 1.66533e-15 -2.22045e-15 -7.77156e-16 1.88738e-15 7.77156e-16 -1.33227e-15 -1.58207e-15
-2.32374e-14 3.33067e-15 7.77156e-16 -3.33067e-16 -1.66533e-15 -2.55351e-15 -1.94289e-15 2.498e-16
-8.16448e-15 3.10862e-15 5.55112e-16 1.27676e-15 1.94289e-15 7.21645e-16 5.55112e-16 1.95677e-15
2.69271e-14 1.38778e-15 -4.60743e-15 -1.9984e-15 7.21645e-16 3.02536e-15 -2.35922e-15 9.15934e-16
2.57495e-13 5.93969e-15 -2.94209e-15 1.7486e-15 -8.32667e-17 -8.32667e-16 -9.15934e-16 1.08941e-15
-3.88284e-13 -1.33227e-15 -1.9984e-15 1.05471e-15 9.29812e-16 7.21645e-16 5.34295e-16 3.66027e-15
```
2. N = 16, N = 25, N = 30 and N = 100
Because the limitation of the body length, the input / output contents of N = 16, N = 25 and N = 30 are as [here](https://gist.github.com/Jimmy-Hu/eb7372b50fb2e97a59c14f3a9b130396). Based on my experiment, when N is up to 25, the run time is about a few seconds.
3. Different size case in each dimension
N1 = 40, N2 = 30, N3 = 20
Note:
* Each test case is run separately (not parallelly) to ensure the computing resource is available.
* The needed compilers and interpreters are installed for testing.
**Winning Criterion & Scores**
This is a [fastest-code](/questions/tagged/fastest-code "show questions tagged 'fastest-code'") challenge, the runtime performance is determined. Scores are from running on my desktop with an AMD 3950x CPU (16C / 32T) and 64GB of 3600MHz RAM.
]
|
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
Questions without an **objective primary winning criterion** are off-topic, as they make it impossible to indisputably decide which entry should win.
Closed 3 years ago.
[Improve this question](/posts/218073/edit)
Here is the problem, for which I can only think of an iterative solution and have not found a closed formula:
* You need to paint a house with R rooms.
* For each room there are four walls and one ceiling, which all have the same dimensions and need C coats of paint.
* You can't paint the next coat until the previous one has dried. You're finished when every wall is dry. Time taken to move between walls, ceilings, rooms is negligible.
* It takes you M1 minutes to paint each coat, and M2 minutes for the paint to dry on each. You must finish in the least possible time, otherwise they will not pay you.
**Note:** Don't forget, the paint must all be dry before you can receive your payment!
### Inputs:
* R, C, M1, and M2, in order and delimited with any consistent separator
* R: Number of rooms in the house
* C: Coats of paint needed for each wall/ceiling
* M1: Minutes taken to paint each coat
* M2: Minutes taken for paint to dry on each coat (measured from when you've finished the entire coat)
### Outputs:
* The hours and minutes taken to paint the entire house
### Constraints:
* 1 ≤ R ≤ 10
* 1 ≤ C ≤ 20
* 1 ≤ M1 ≤ 10000
* 1 ≤ M2 ≤ 10000
### Examples:
```
1 1 12 0 => 1:00
5 2 5 30 => 4:40
1 5 5 200 => 17:25
```
```
]
|
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/217527/edit).
Closed 3 years ago.
[Improve this question](/posts/217527/edit)
Let S be a set of sets, for example `S = {{A},{B},{A,B}}`. A maximal subset, `Max`, is an element of S such that no other set in S strictly includes `Max`. So in this example, {A,B} is a maximal subset as none of the other sets strictly contain {A,B}.
A minimal subset, `Min`, is an element of S such that no other set in S is strictly included in `Min`. So in this example, {A} and {B} are both minimal subsets as none of the other sets are strictly contained in {A} or {B}.
## Function input and output
Input: A set `S` which contains an arbitrary number of other sets. These sets can have any range of alphanumeric values and can include the empty set. Example of inputs: `{{a1},{a2},{a1,a2},{a2,a3}}` and `{{},{a1},{a2}}`
Outputs: A value for `Min`, which corresponds to the minimal subset as defined above and a value for `Max` as defined by the maximal subset as defined above. These two outputs should be printed and it should be clear which is the `Min` and which is the `Max`, examples given in the test cases.
The output is what is important here, as long as you can achieve it, you may use any range of functions.
## Test cases
```
{{a1},{a2},{a1,a2},{a2,a3}} => Min = {{a1},{a2}}, Max = {{a1,a2},{a2,a3}}
{{a1},{a1,a3},{a1,a4}} => Min = {{a1}}, Max = {{a1,a3},{a1,a4}}
{{a1},{a1,a4,a5},{a2,a3,a5}} => Min = {{a1}}, Max = {{a1,a4,a5},{a2,a3,a5}}
{{},{a1},{a2}} => Min = {{}}, Max = {{a1},{a2}}
{{}, {a1}, {a2, a4}} => Min = {{}}, Max = {{a1}, {a2, a4}}
{{}, {a1}, {a2, a3}, {a2, a3, a4}} => Min = {{}}, Max = {{a1}, {a2, a3, a4}}
```
]
|
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/217472/edit).
Closed 3 years ago.
[Improve this question](/posts/217472/edit)
## Input
* Your program will take in the integer coefficients of the equation \$ax^3+bx^2+cx+d=0\$ as inputs (a, b, c, and d).
## Output
* All real solutions of the input equation, with an accuracy of at least the thousandths place, sorted from smallest to largest.
## Rules
* Built-in equation solver are not allowed
* Native math libraries that do not solve equations may be used
* If you have any questions, please ask in comment
## Examples
1. .
Input:
```
1 2 3 4
```
Output:
```
-1.651
```
2. .
Input:
```
1 3 0 -1
```
Output:
```
-2.879 -0.653 0.532
```
]
|
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/215717/edit).
Closed 3 years ago.
[Improve this question](/posts/215717/edit)
It is quite simple, any language, make output show the time in the HH:MM or HH:MM:SS while the numbers and the colons being ascii art(The output is ascii art not the program)
Sample output:
```
____________ ________ _____ .________ ________
/_ \_____ \ /\ \_____ \ / | | /\ | ____// _____/
| |/ ____/ \/ _(__ < / | |_ \/ |____ \/ __ \
| / \ /\ / \/ ^ / /\ / \ |__\ \
|___\_______ \ \/ /______ /\____ | \/ /______ /\_____ /
\/ \/ |__| \/ \/
```
Bonus points: Add a PM/AM thingy
Bonus points 2: Make it blink 1 time per second(0.5 sec time 0.5 sec no time)
]
|
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/215118/edit).
Closed 3 years ago.
[Improve this question](/posts/215118/edit)
I have a problem, which I haven't found a solution for. Solutions to the first part are well documented, but I have yet to find anyone who has solved the second part. I call this the "Dobble" challenge...
## Challenge 1
Using the numbers 1 - 57, populate 57 arrays. Each array must have 8 numbers in it, with no duplicates. Each array must share **one number** (and **only** one number) with every other array. For example:
`[3, 12, 18, 24, 30, 43, 49, 55]`
`[4, 13, 18, 23, 35, 40, 45, 57]`
`[7, 10, 19, 28, 30, 39, 48, 57]`
The first array has `18` in common with second array and `30` in common with the third array.
This challenge has been [posted before](https://codegolf.stackexchange.com/questions/101229/dobble-spotit-card-generator), and published solutions can easily be found and explained. But wait...
## Challenge 2
As an extension to the previous challenge, ensure that each of the numbers 1 - 57 are **never in the same position twice**, across all of the 57 arrays. For instance, the previous example contains `30` twice in the fifth position. Find a solution that avoids this.
This is my first code challenge, so please forgive any issues with the formatting/style - I'll try to correct errors if you mention them in the comments.
]
|
[Question]
[
## Introduction
Gijswijt's sequence ([A090822](https://oeis.org/A090822)) is famously really, REALLY slow. To illustrate:
* The first 3 appears in the 9th term (alright).
* The first 4 appears in the 220th term (a long way away, but feasible).
* The first 5 appears at (approximately) the **10^(10^23)th term** (just no).
* No one really even knows where the first 6 is... it's suspected it's at the...
### 2^(2^(3^(4^5)))th term.
**You can assume that you won't have to deal with a two-digit number.**
The sequence is generated like so:
1. The first term is 1.
2. Each term after that is the amount of repeating "blocks" previous to it (if there are multiple repeating "blocks", the largest amount of repeating blocks is used).
To clarify, here are the first few terms.
`1 -> 1, 1` (one repeating block (`1`), so the digit recorded is `1`)
`1, 1 -> 1, 1, 2` (two repeating blocks (`1`), so the digit recorded is `2`)
`1, 1, 2 -> 1, 1, 2, 1` (one repeating block (`2` or `1, 1, 2`), so the digit recorded is `1`)
`1, 1, 2, 1 -> 1, 1, 2, 1, 1` (you get the idea)
`1, 1, 2, 1, 1 -> 1, 1, 2, 1, 1, 2`
`1, 1, 2, 1, 1, 2 -> 1, 1, 2, 1, 1, 2, 2` (two repeating blocks (`1, 1, 2`), so the digit recorded is `2`)
## Task
Your task is, as stated in the question, to generate n digits of the Gijswijt sequence.
## Instructions
* The input will be an integer `n`.
* Your code can output the digits in any form (a list, multiple outputs, etc.).
This is code golf, so shortest code in bytes wins.
[Answer]
# Pyth, ~~25~~ ~~22~~ 21 bytes
```
t_u+eSmtfxG*Td1._GGQN
```
OP confirmed that we only need to handle single-digit numbers. This allowed to store the list as a string of digits. -> Saved 3 bytes
Try it online: [Demonstration](http://pyth.herokuapp.com/?code=t_u%2BeSmtfxG*Td1._GGQN&input=30&debug=0)
### Explanation:
```
t_u+...GQN implicit: Q = input number
N start with the string G = '"'
u Q do the following Q times:
... generate the next number
+ G and prepend it to G
_ print reversed string at the end
t remove the first char (the '"')
```
And here's how I generate the next number:
```
eSmtfxG*Td1._G
._G generate all prefixes of G
m map each prefix d to:
f 1 find the first number T >= 1, so that:
*Td d repeated T times
xG occurs at the beginning of G
S sort all numbers
e take the last one (maximum)
```
### 21 bytes with lists
```
_u+eSmhhrcGd8SlGGtQ]1
```
Try it online: [Demonstration](http://pyth.herokuapp.com/?code=_u%2BeSmhhrcGd8SlGGtQ]1&input=20&debug=0)
Uses the same ideas of Martin and Peter. At each step I split the string into pieces of length 1, pieces of length 2, ... Then I range-length-encode them and use the maximal first run as next number.
### 20 bytes with strings
```
t_u+eSmhhrcGd8SlGGQN
```
Try it online: [Demonstration](http://pyth.herokuapp.com/?code=t_u%2BeSmhhrcGd8SlGGQN&input=20&debug=0)
Combines the ideas of the two codes above.
[Answer]
## CJam, ~~33~~ ~~31~~ ~~30~~ 27 bytes
*Thanks to Peter Taylor for saving 1 byte.*
```
1sri({),:)1$W%f/:e`$W=sc+}
```
[Test it here.](http://cjam.aditsu.net/#code=1sri(%7B)%2C%3A)1%24W%25f%2F%3Ae%60%24W%3Dsc%2B%7D%2F&input=220)
### Explanation
```
1s e# Initialise the sequence as "1".
ri( e# Read input N and decrement.
{ e# For each I from 0 to N-1...
) e# Increment to get I from 1 to N.
, e# Turn into a range [0 1 ... I-1].
:) e# Increment each element to get [1 2 ... I].
1$ e# Copy sequence so far.
W% e# Reverse the copy.
f/ e# For each element x in [1 2 ... I], split the (reversed) sequence
e# into (non-overlapping) chunks of length x. These are the potentially
e# repeated blocks we're looking for. We now want to find the splitting
e# which starts with the largest number of equal blocks.
:e` e# To do that, we run-length encode each list blocks.
$ e# Then we sort the list of run-length encoded splittings, which primarily
e# sorts them by the length of the first run.
W= e# We extract the last splitting which starts with the longest run.
sc e# And then we extract the length of the first run by flattening
e# the list into a string and retrieving the first character.
+ e# This is the new element of the sequence, so we append it.
}/
```
[Answer]
## CJam (30 29 27 24 bytes)
```
'1ri{{)W$W%/e`sc}%$W>+}/
```
[Online demo](http://cjam.aditsu.net/#code='1ri%7B%7B)W%24W%25%2Fe%60sc%7D%25%24W%3E%2B%7D%2F&input=220)
This is very much a joint effort with Martin.
* The clever use of run-length encoding (`e``) to identify repetitions is Martin's
* So is the use of `W$` to simplify the stack management
* I eliminated a couple of increment/decrement operations by using `$W>+` special-casing, as explained in the dissection below
---
My first 30-byte approach:
```
1ari{,1$f{W%0+_@)</{}#}$W>+}/`
```
[Online demo](http://cjam.aditsu.net/#code=1ari%7B%2C1%24f%7BW%250%2B_%40)%3C%2F%7B%7D%23%7D%24W%3E%2B%7D%2F%60&input=220)
### Dissection
```
1a e# Special-case the first term
ri{ e# Read int n and iterate for i=0 to n-1
,1$f{ e# Iterate for j=0 to i-1 a map with extra parameter of the sequence so far
W%0+ e# Reverse and append 0 to ensure a non-trivial non-repeating tail
_@)</ e# Take the first j+1 elements and split around them
{}# e# Find the index of the first non-empty part from the split
e# That's equivalent to the number of times the initial word repeats
}
$W>+ e# Add the maximal value to the sequence
e# NB Special case: if i=0 then we're taking the last term of an empty array
e# and nothing is appended - hence the 1a at the start of the program
}/
` e# Format for pretty printing
```
[Answer]
## Haskell, 97 bytes
```
f 1=[1]
f n|x<-f$n-1=last[k|k<-[1..n],p<-[1..n],k*p<n,take(k*p)x==([1..k]>>take p x)]:x
reverse.f
```
The third line defines an anonymous function that takes an integer and returns a list of integers.
[See it in action.](http://ideone.com/CTGlIH)
## Explanation
The helper function `f` constructs the sequence in reverse, by recursively checking whether the previous sequence begins with a repeated block.
`k` is the number of repetitions, and `p` is the length of the block.
```
f 1=[1] -- Base case: return [1]
f n|x<-f$n-1= -- Recursive case; bind f(n-1) to x.
last[k|k<-[1..n], -- Find the greatest element k of [1..n] such that
p<-[1..n], -- there exists a block length p such that
k*p<n, -- k*p is at most the length of x, and
take(k*p)x -- the prefix of x of length p*k
== -- is equal to
([1..k]>>take p x) -- the prefix of length p repeated k times.
]:x -- Insert that k to x, and return the result.
reverse.f -- Composition of reverse and f.
```
[Answer]
## [Retina](https://github.com/mbuettner/retina), ~~66~~ 60 bytes
```
+1`((\d+)?(?<1>\2)*(?<!\3(?>(?<-1>\3)*)(?!.*\2)(.+)))!
$1$#1
```
Input is a unary integer using `!` as the digit (although that could be changed to any other non-numeric character). Output is simply a string of digits.
[Try it online!](http://retina.tryitonline.net/#code=KzFgKChcZCspPyg_PDE-XDIpKig_PCFcMyg_Pig_PC0xPlwzKSopKD8hLipcMikoLispKSkhCiQxJCMx&input=ISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhIQ) (Alternatively, for convenience [here's a version that takes decimal input.](http://retina.tryitonline.net/#code=LisKJCohCisxYCgoXGQrKT8oPzwxPlwyKSooPzwhXDMoPz4oPzwtMT5cMykqKSg_IS4qXDIpKC4rKSkpIQokMSQjMQ&input=MzA))
For testing purposes, this can be sped up *a lot* with a small modification, which allows testing of input 220 in under a minute:
```
+1`((\d+)?(?<1>\2)*(?=!)(?<!\3(?>(?<-1>\3)*)(?!.*\2)(.+)))!
$1$#1
```
[Try it online!](http://retina.tryitonline.net/#code=KzFgKChcZCspPyg_PDE-XDIpKig_PSEpKD88IVwzKD8-KD88LTE-XDMpKikoPyEuKlwyKSguKykpKSEKJDEkIzE&input=ISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhIQ) ([Decimal version.](http://retina.tryitonline.net/#code=LisKJCohCisxYCgoXGQrKT8oPzwxPlwyKSooPz0hKSg_PCFcMyg_Pig_PC0xPlwzKSopKD8hLipcMikoLispKSkhCiQxJCMx&input=MjIw))
If you want to test even larger numbers, it's best to just feed it some massive input and put a `:` after the initial `+`. This will make Retina print the current sequence each time it finishes computing a new digit (with all the digits off-by-one).
### Explanation
The solution consists of a single regex substitution, which is applied to the input repeatedly until the result stops changing, which in this case happens because the regex no longer matches. The `+` at the beginning introduces this loop. The `1` is a limit which tells Retina only to replace the first match (this is only relevant for the very first iteration). In each iteration, the stage replaces one `!` (from the left) with the next digit of the sequence.
As usual, if you need a primer on balancing groups [I refer you to my SO answer](https://stackoverflow.com/questions/17003799/what-are-regular-expression-balancing-groups/17004406#17004406).
Here is an annotated version of the regex. Note that the goal is to capture the maximum number of repeated blocks in group `1`.
```
( # Group 1, this will contain some repeated block at the end
# of the existing sequence. We mainly need this so we can
# write it back in the substitution. We're also abusing it
# for the actual counting but I'll explain that below.
(\d+)? # If possible (that is except on the first iteration) capture
# one of more digits into group 2. This is a candidate block
# which we're checking for maximum repetitions. Note that this
# will match the *first* occurrence of the block.
(?<1>\2)* # Now we capture as many copies of that block as possible
# into group 1. The reason we use group 1 is that this captures
# one repetition less than there is in total (because the first
# repetition is group 2 itself). Together with the outer
# (unrelated) capture of the actual group one, we fix this
# off-by-one error. More importantly, this additional capture
# from the outer group isn't added until later, such that the
# lookbehind which comes next doesn't see it yet, which is
# actually very useful.
# Before we go into the lookbehind note that at the end of the
# regex there's a '!' to ensure that we can actually reach the
# end of the string with this repetition of blocks. While this
# isn't actually checked until later, we can essentially assume
# that the lookbehind is only relevant if we've actually counted
# repetitions of a block at the end of the current sequence.
(?<! # We now use a lookbehind to ensure that this is actually the
# largest number of repetitions possible. We do this by ensuring
# that there is no shorter block which can be matched more
# often from the end than the current one. The first time this
# is true (since, due to the regex engine's backtracking rules,
# we start from longer blocks and move to shorter blocks later),
# we know we've found the maximum number of repetitions.
# Remember that lookbehinds are matched right-to-left, so
# you should read the explanation of the lookbehind from
# bottom to top.
\3 # Try to match *another* occurrence of block 3. If this works,
# then this block can be used more often than the current one
# and we haven't found the maximum number of repetitions yet.
(?> # An atomic group to ensure that we're actually using up all
# repetitions from group 1, and don't backtrack.
(?<-1>\3)* # For each repetition in group 1, try to match block 3 again.
)
(?!.*\2) # We ensure that this block isn't longer than the candidate
# block, by checking that the candidate block doesn't appear
# right of it.
(.+) # We capture a block from the end into group 3.
) # Lookbehind explanation starts here. Read upwards.
)
! # As I said above, this ensures that our block actually reaches
# the end of the string.
```
Finally, after this is all done, we write back `$1` (thereby deleting the `!`) as well as the number of captures in the group with `$#1` which corresponds to the maximum number of repetitions.
[Answer]
# Pyth, ~~41~~ 38 bytes
```
J]1VSQ=J+h.MZmh+fn@c+J0dT<JdSNZSNJ;P_J
```
[Try it online!](http://pyth.herokuapp.com/?code=J%5D1VSQ%3DJ%2Bh.MZmh%2Bfn%40c%2BJ0dT%3CJdSNZSNJ%3BP_J&input=9&debug=0)
[Answer]
# Ruby, 84 bytes
The Retina answer inspired me to do a regex-based solution to find the best sequence instead of somehow counting sequences in an array, but with less of the genius (negative lookbehinds with quantifiers don't seem to be allowed in Ruby, so I doubt I could directly port Retina's answer over anyways)
```
->n{s='';n.times{s+=(1..n).map{|i|s=~/(\d{#{i}})\1+$/?$&.size/i: 1}.max.to_s};s[-1]}
```
Given an already-generated sequence `s`, it maps over all `i` from `1` to `s.length` (`n` was used in this case to save bytes since `n>=s.length`) and then uses this regex to help calculate the number of repetitions of a subsequence with length `i`:
```
/(.{#{i}})\1+$/
/( # Assign the following to group 1
.{#{i}} # Match `i` number of characters
) # End group 1
\1+ # Match 1 or more repetitions of group 1
$/ # Match the end of string
```
If a match is found of that length, it calculates the number of repetitions by dividing the length of the given match `$&` by `i`, the length of the subsequence; if no match was found, it is treated as `1`. The function then finds the maximum number of repetitions from this mapping and adds that number to the end of the string.
] |
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
Questions without an **objective primary winning criterion** are off-topic, as they make it impossible to indisputably decide which entry should win.
Closed 3 years ago.
[Improve this question](/posts/210314/edit)
I just realized that Python allows more than names as `for` loop iteration variables:
```
for a[i] in sequence:
pass
```
The real fun begins when `a` and `i` change during the loop. The following function inverts a list `a` in place while printing the intermediate steps. **All assignments occur implicitly in the iteration variables:**
```
def reverse_list_with_log(a):
print(a)
print("\n".join(str(a) for (i, (a[i], a[~i])) in enumerate(zip(a[::-1], a[:len(a) // 2]))))
a = [1, 2, 3, 4, 5, 6, 7, 8, 9]
reverse_list_with_log(a)
assert a == [9, 8, 7, 6, 5, 4, 3, 2, 1]
```
Output:
```
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[9, 2, 3, 4, 5, 6, 7, 8, 1]
[9, 8, 3, 4, 5, 6, 7, 2, 1]
[9, 8, 7, 4, 5, 6, 3, 2, 1]
[9, 8, 7, 6, 5, 4, 3, 2, 1]
```
Equivalent normal version:
```
def reverse_list_with_log(a):
print(a)
for i in range(len(a) // 2):
(a[i], a[~i]) = (a[~i], a[i])
print(a)
```
Could you come up with other creative uses of this "feature" (a subscription as the iteration variable)? No explicit assignment allowed (i.e., `a = b`) in the main treatment. Please give the readable version along with your proposition.
**Disclaimer.** This is my first question on this site, and I am aware that I cannot really set an objective winning criterion. However, I have seen in other questions that the variety of ideas and solutions frequently deserves reading beyond the winning answer. Feel free to improve or close my question if it cannot be salvaged.
]
|
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
Questions without an **objective primary winning criterion** are off-topic, as they make it impossible to indisputably decide which entry should win.
Closed 3 years ago.
[Improve this question](/posts/209207/edit)
# Introduction
Programmers have already [solved](https://codegolf.stackexchange.com/questions/136493/solve-the-trolley-problem) the trolley problem (a [classical problem](https://en.wikipedia.org/wiki/Trolley_problem) in philosophy). In the usual trolley problem, we have a directed graph and each edge is weighted by the number of people tied to the track (edge). The objective of the usual trolley problem is to find a path through the graph that minimizes the number of people killed by the train. But what about multitrack drifting?
[](https://i.stack.imgur.com/MGzIv.png)
# Challenge
In the trolley problem with multitrack drifting, the objective is reversed: Let's run over the largest number of people possible. Our trolley has a front carriage and a back carriage. By quickly throwing a lever after the front carriage goes over the track switch but before the back carriage goes over it, we can get the two carriages to separate onto two different tracks, maximizing the carnage. However, the trolley will be derailed unless there is a planar embedding of the graph for which the two carriages follow paths for which the corresponding vertices of the two paths are always on the same face of the planar embedding. The planar embedding must be fixed throughout the whole journey of the trolley.
# Input and Output
**Input:** A directed, rooted, acyclic planar graph, with integer weights on the edges. The front and back carriages both begin at the root vertex. Please assume that all directed paths starting at the root and ending at a vertex with out-degree zero are of the same length. This implies that if any two directed paths start at the root or the same vertex and end at a vertex with out-degree zero or the same vertex (resp), then they have the same length (we can't 'go faster' by going one way or another, at a junction).
**Output:** The maximum sum of edge weights over all pairs of directed paths through the graph. Each of the two paths in the pair (the carriages) must start at the root vertex and end at a vertex with out-degree zero. If the vertices specified by the two paths are (*x1,x2,x3,...*) and (*y1,y2,y3,...*) then there must be a planar embedding of the graph such that *xi* and *yi* are always vertices of the same face of the planar embedding.
**Notes:** Please assume any input and output formats that can fully specify the situation (bytes, ascii, etc). Also, for clarifications: For a directed path, each edge of the directed path must match the direction of the corresponding edge of the input acyclic graph. Further, the number of edges between two vertices is at most one (it's not a 'multi-graph'), and no edge can connect a vertex to itself (no loops, as implied by acyclic property).
]
|
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
Closed 3 years ago.
* This site is for programming contests and challenges. **General programming questions** are off-topic here. You may be able to get help on [Stack Overflow](http://stackoverflow.com/about).
* Questions without an **objective primary winning criterion** are off-topic, as they make it impossible to indisputably decide which entry should win.
[Improve this question](/posts/203323/edit)
Here's an interview question I've seen on a few sites. People claim that an `O(n)` solution is possible, but I've been racking my brain these last 2 days and I couldn't come up with a solution, nor find one anywhere on the web.
Given an array of integers, find two disjoint, contiguous subarrays such that the absolute difference between the sum of the items in each subarray is as big as possible.
Example input: `(2, -1, -2, 1, -4, 2, 8)`
Example output: `((1, 4), (5, 6))`
The output above is the indices of these two subarrays: `((-1, -2, 1, -4,), (2, 8))`
I've been trying to reduce this problem to the [Maximum subarray problem](https://en.wikipedia.org/wiki/Maximum_subarray_problem) but with no success.
]
|
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/199455/edit).
Closed 4 years ago.
[Improve this question](/posts/199455/edit)
Write a program that when given a string \$S\$, it generates a program of the same language as itself.
The generated program, when given a continuous substring of \$S\$, should predict the next character in an occurence of the subtring in \$S\$. You are guaranteed that this substring occurs exactly once in \$S\$ and does not occur at the end of \$S\$. \$S\$ will be a string of at most \$10000\$ characters consisting of only lowercase English letters.
The program that **you are submitting** will only be given \$S\$. The program that **your program generates** will be given a list of substrings and should return a list of answers in an acceptable format.
This is [code-challenge](/questions/tagged/code-challenge "show questions tagged 'code-challenge'"), and the scoring criterion is as follows:
The **score of the generated program** is equal to \$\frac{|S|c}{1+Lt}\$, where \$|S|\$ is the length of the string, \$c\$ is the number of correct predictions, \$L\$ is the length of the generated program, and \$t\$ is the total number of predictions.
The **score of your submission** is the **minimum** score of your generated programs across all testcases.
Users are welcome to "hack" other people's submissions by proposing new test cases in order to decrease submissions' scores.
Some example test cases can be found [here](https://www.luogu.com.cn/paste/xkfeih6g) (currently only two test cases, I will add more later).
]
|
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/198478/edit).
Closed 4 years ago.
[Improve this question](/posts/198478/edit)
Something unusual: a code golf question with a purpose.
I occasionally find myself in scenarios resembling the following:
Suppose you have two computers, A and B. Both of them have a fresh copy of Windows 10 installed. It comes with all the usual stuff, like notepad and paint and a browser, but no extras, like a Linux tools port. They ALSO have had Remote Desktop and the built in File Sharing removed/disabled. Computer A has one extra thing - a large-ish file (say, 10 MB) that you need to get onto Computer B. Computers A and B are connected over a LAN, but they are not connected to the internet. Their USB drives have been disabled, and they have no other data I/O peripherals. No disassembling the computers.
In the fewest possible steps, how do you get The File between LAN'd computers A and B, running default Windows 10, with no internet and no external storage devices?
I'm expecting something like "if you type such-and-such line into PowerShell, it takes a pipe and outputs it into a TCP connection", or "if you abuse the browser in such-and-such a way, it lets you host an FTP server". BUT, I'm open to surprises - as long as they're actually feasible.
]
|
[Question]
[
Your challenge is simple. Write two programs that share no characters which output each other.
## Example
Two programs **P** and **Q** are mutually exclusive quines if:
1. **P** outputs **Q**
2. **Q** outputs **P**
3. There is no character *c* which belongs to both **P** and **Q**
4. Each program **P** and **Q** are [**proper quines**](https://codegolf.meta.stackexchange.com/questions/4877/what-counts-as-a-proper-quine)
1. This counts empty quines and quines that read their own (or the other's) source code as **invalid**.
## More rules
* The shortest combined length of these programs wins. That is, size(**P**) + size(**Q**) is your score, and the lowest score wins.
* Both programs are in the same language
* Each program may be a full program or function, and they need not be the same.
+ For example, **P** may be a full program and **Q** may be a function.
## Verification
This [Try it online!](https://tio.run/##TY67asNAFET7/Yqx0kh42Q8IhJAi2I0bF0m9urqKF65W0j6Mhe1v30ipMtUwDIcTcruU0nEPqgeN2CisiYYuNkQTWZgS7njQA4NxvuMbCE/FvlPKarR4w8f58KXmtdRUb1OD/QprNWzTmOzdrFyP2fAwpeX9Dz/lFFGdcspWZAHfSHJ0V95ViiXyv89nCGPQoNH34ig5/4PNzFLiEF/xcp@f1SZTSjmyyKjxPQbpduXiRH4B "Ruby – Try It Online") snippet here can verify whether or not two programs are mutually exclusive. The inputs are put in the first two arguments.
[Answer]
# [><>](https://esolangs.org/wiki/Fish), Score: 41+41 = 82
Edit: both contained a 3. Fixed
```
'd3*}>a!o-!<<8:5@lI55>@z:5ll55>>q:>|q::|,
```
and
```
"r00gr40g44++bb+0p64++?b6+0.22#eW4s )Z
```
[Try it online!](https://tio.run/##S8sszvj/Xz3FWKvWLlExX1fRxsbCytQhx9PU1M6hyso0JwfIsCu0sqsptLKq0eFSKjIwSC8yMUg3MdHWTkrSNigwAzLsk8y0DfSMjMSVU8XDTYoVNKNk//8HAA) (swap the lines to get the other output) [With verification this time!](https://tio.run/##TY69ToRAGEX7eYFtP9hCEJyQFTZmsrJrYYzFNhaa2MHwgZMMf/NjFheeHcHKW53c3JxcZfNhngssgXt1CNonsERT/pUpTTVK5AauMPIRaiqaAi/AYSLYFIRkIeTwCE9vL@@kX8Dj3lr5ECyyPITM96ltRE9ECT3FujPD8U/fWaPBPVtjMykHwAuXVotvdFyCUuO/zbNSrQqBt00pBTeiqWB9lnGDSjPYXvvJXc/M83xT3N9Oaea0d87h8MCSk3xNkvT0wxIpF0h7lo49Y2M4uyqKKhVHVRwHQZ4HUbdf4Jjvg4judpstbj5iDf7nLw "Ruby – Try It Online")
`><>` is an especially hard language to use here, as there is only one way to output characters, the command `o`. Fortunately, we can use the *p*ut command to place an `o` in the source code during execution, like in my [Programming in a Pristine World](https://codegolf.stackexchange.com/a/153233/76162) answer.
This one took a *lot* of trial and error. I started off with the two mutually exclusive programs:
```
'd3*}>N!o-!<<data
```
and
```
"r00gr40g8+X0pN+?Y0.data
```
Each one transforms itself and its data by N, the first one subtracting and the second adding. It then outputs this in reverse. The point is that the data after each program is the other program in reverse, shifted by N. (`X` is the cell number where the program needs to put the `o` and Y is the cell where the pointer loops back to. `?` is where the `o` is put).
Both follow the same structure, represented in different ways. They run a string literal over the entire code, adding it to the stack. They recreate the string literal command they used and put it at the bottom of the stack. They loop over the stack, adding/subtracting N to each character and printing them.
The first program uses `'` as the string literal, and the simple `d3*}` to create the value 39 and push it to the bottom of the stack. The second uses `"` as the string literal with the same function. It `r`everses the stack, `g`ets the character at cell 0,0 and reverses the stack again. It then `g`ets the value at cell 4,0 (`g`) and adds 8 to it to get `o` and puts that at X.
Both programs use a different method of looping. The first program uses the skip command (`!`) to run only half the instructions while going left, reverses direction and runs the other half. The second uses the jump command (`.`) to skip backwards to the start of the loop at cell Y. Both of these run until there are no more items on the stack and the program errors.
I ran into a number of problems with most of the lower values of N, because shifting one character would turn it into another character essential for that program (and therefore couldn't be used as data for the other program) or two characters from the two programs would shift into the same character. For example:
1. `+`+1 = `,` = `-`-1
2. `.`+2 = `0`
3. `*` = `-`-3
4. `g`+4 = `k` = `o`-4
etc.
Eventually I got to 10 (`a`), where I was able to avoid these issues. There might be a shorter version where the shifts are reversed, and the first program is adding N while the second subtracts it. This might be worse off though, as the first program is generally on the lower end of the ASCII scale, so subtracting is better to avoid conflicts.
[Answer]
# [Forth (64-bit little-endian gforth)](http://www.complang.tuwien.ac.at/forth/gforth/Docs-html/), 428 + 637 = 1065 bytes
```
s" : l bl - ; : m l emit ; : s space ; : z m m m m s ; : p . 't 'i 'm 'e z ; 'e 'r 'e 'h z : q >r char l bl l do dup @ . 'L m s cell+ loop r> . ; : n 'e 'p 'y 't z ; q ; 's p 'B l p #tab p 'p 'u 'd 'Q char+ z n 'B l p n": l bl - ; : m l emit ; : s space ; : z m m m m s ; : p . 't 'i 'm 'e z ; 'e 'r 'e 'h z : q >r char l bl l do dup @ . 'L m s cell+ loop r> . ; : n 'e 'p 'y 't z ; q ; 's p 'B l p #tab p 'p 'u 'd 'Q char+ z n 'B l p n
```
```
HERE 3245244174817823034 , 7784873317282429705 , 665135765556913417 , 7161128521877883194 , 682868438367668581 , 679209482717038957 , 680053688600562035 , 678116140452874542 , 682868623551327527 , 680649414991612219 , 682868636436227367 , 7136360695317203258 , 7809815063433470312 , 8458896374132993033 , 5487364764302575984 , 7810758020979846409 , 680166068077538156 , 4181938639603318386 , 8081438386390920713 , 8793687458429085449 , 2812844354006760201 , 7784826166316108147 , 676210045490917385 , 681493840106293616 , 7521866046790788135 , 679491013524025953 , 7928991804732031527 , 216 115 EMIT 34 EMIT 9 EMIT 2DUP TYPE 34 EMIT TYPE
```
[Try it online!](https://tio.run/##3Y9NDoMgEIXX7xp2MQtjD6CJabrupkfwB4sJCgIu7OXpDKY9RMOEmQeP74XJ@qir1yQtpVCghkFvUKHhcWGhljlm8WZ5ruC6QeUzhysogmbQAlLsaaSRz7tmXWND6zHozp9kg9Fi3B1u8vbxww3KmBLGWgff8pXg14xxoENSBL5JQOBcujPJ4RK7XhTXDhpBzxxVsnn9etbiHz@V0gc)
[Verification script](https://tio.run/##3VLbbtNAEH3efMWSPrhRQ7Q7e5nZVpSLiACJSqUqSDwmjkstOY7jC2po@@1hdkML34BjZT3jM2fmnHE7LHf7/aq4kfnxeiq7yUjy1c3y20XbzbqiKvJe3suH/EGuZ2W9Ku5kLh9HRb0ajRZTuZSv5NurD99GW344zo9jaiJPmGw5lYvJZDbU5XZU3sjtrFg3/e51om@GvpPji6EfFlW1k8VdXg1d@bN4MR4VVVf8g5m37aadynxT31Rl3pf1DxknW@R90Xan8uh@@ziOw@z3@24sTkUllpV4Kc74cc1BsS77FPzi8PDrmkVepFwjZiLrRVaKbC2ygjFn8cja9H/L8anYivNWxI4H5kqsNmI1NOJNrP38TJcXVXUiqs2mEe05v4r0daJpRLaLXSL5NjbouG/2jpkacdQvljHiexDZSmRfUqsTBtdPmHr8P4raf5xfzaUB68BajZY0EhhlrJxKRLKExmgEAgsBleOs904bh94554M2XBSTGEAFS4BcHxRhqtdeayAHmhBtUApChJJSzngiz6cHBTrVk2a0VTwHFzsLCQnkyYNx3BHQAR7KvQ1W2xC4AECHv0jjrfEAaDym9oYzygcXFSgDjmKWVCDtlDfWGIvK6NiKrCMK3qDlTiGwAYazLsr3FplWgUMXKMkyymFQ2rE6RjJIP5mltEa2RXsXtI1mJfOcBtZquSWZNC6QBrbD8onIrlA4KAOvA1qltNFRR4QS82iu5AJvrYnzPnsYjOEFoFOQJgBeoUfgdsQWsvbkFymmMMRitSGFJiD8mYAF86i8NfQKVKL1Ci06w2rZdovwLIwn8zyECzwvRQL@HGzg/VvgFYOPWoGd1NrJ@cWna8kfUDrD4YD3Xy/l9ffL@fOLFPwG)
Thanks to [@Nathaniel](https://codegolf.stackexchange.com/questions/153948/mutually-exclusive-quines#comment375937_153948) for the idea of using Forth - he reminded me in the comments that **Forth is not case-sensitive**. Then came the mood swings - I've been finding reasons why this will not work, followed by solutions to these problems, again and again. All while spinning my indoor training bike like an oversided and misshaped fidget spinner (you just have to grab one end of the handle bar and tilt it a bit).
Before writing these programs, I drafted what characters can be used by which program. Specifically, the second program can only use uppercase letters, decimal digits, tabs, and commas. This would mean that the first program is all lowercase, but I used some uppercase letters for their ASCII values.
Because tabs are unwieldy, I'll use spaces in the explanation instead.
The first program is of the form `s" code"code` - the `s"` starts a string literal, which is then processed by the second copy of the code - a standard quine framework. However, instead of outputting its own source code, it will create the other program, which looks like this:
* `HERE`
* For each 8 bytes in the original string, `64-bit-number-literal ,`
* `length-of-the-string`
* `115 EMIT 34 EMIT 9 EMIT 2DUP TYPE 34 EMIT TYPE`
This uses Forth's data space. `HERE` returns the pointer to the end of the currently allocated data space area, and `,` appends a cell filled with a number to it. Therefore, the first three bullet points can be seen like a string literal created using `s"`. To finish the second program off:
* `EMIT` outputs a character given its ASCII value, so:
+ `115 EMIT` prints a lowercase `s`
+ `34 EMIT` prints the quote character `"`
+ `9 EMIT` prints a tab
* `2DUP` duplicates the top two elements on the stack `( a b -- a b a b )`, here it's the pointer to and the length of the string
* `TYPE` prints a string to output the first copy of the code
* `34 EMIT` prints the closing quote `"`, and finally
* `TYPE` outputs the second copy of the code
Let's see how the first program works. In many cases numbers have to be avoided, which is done using the `'x` gforth syntax extension for character literals, and sometimes subtracting the ASCII value of space, which can be obtained using `bl`:
```
s" ..." \ the data
: l bl - ; \ define a word, `l`, that subtracts 32
: m l emit ; \ define a word, `m`, that outputs a character. Because 32 is
\ subtracted using `l`, lowercase characters are converted to
\ uppercase, and uppercase characters are converted to some
\ symbols, which will become useful later
: z m m m m space ; \ `z` outputs four characters using `m`, followed by a
\ space. This is very useful because all words used in the
\ second program are four characters long
: p . 't 'i 'm 'e z ; \ define a word, `p`, that, given a number, outputs that
\ number, followed by a space, `EMIT`, and another space
'e 'r 'e 'h z \ here is where outputting the second program starts - `HERE `
: q \ define a helper word, `q`, that will be called only once. This is done
\ because loop constructs like do...loop can't be used outside of a word.
>r \ q is called with the address and the length of the data string. >r saves
\ the length on the return stack, because we don't need it right now. While
\ it might seem like this is too complicated to be the best way of doing
\ this for codegolf, just discaring the length would be done using four
\ characters - `drop`, which would give you the same bytecount if you could
\ get the length again in... 0 characters.
char l \ get a character from after the call to q, which is `;`, with the
\ ASCII value of $3B, subtract $20 to get $1B, the number of 64-bit
\ literals necessary to encode the string in the second program.
bl l \ a roundabout way to get 0
do \ iterate from 0 (inclusive) to $1B (exclusive)
\ on the start of each iteration, the address of the cell we are currently
\ processing is on the top of the stack.
dup @ . \ print the value. The address is still on the stack.
'L m space \ the ASCII value of L is exactly $20 larger than the one of ,
cell+ \ go to the next cell
loop
r> . \ print the length of the string
;
: n 'e 'p 'y 't z ; \ define a word, `n`, that outputs `TYPE`
q ; \ call q, and provide the semicolon for `char` (used to encode the length
\ of the string in 64-bit words). Changing this to an uppercase U should
\ make this work on 32-bit systems, but I don't have one handy to check that
's p \ print the code that outputs the lowercase s
'B l p \ likewise, 'B l <=> $42 - $20 <=> $22 <=> the ASCII value of a comma
#tab p \ print the code that outputs a tab
'p 'u 'd 'Q char+ z \ char+ is the best way to add 1 without using any digits.
\ it is used here to change the Q to an R, which can't be
\ used because of `HERE` in the second program. R has an
\ ASCII value exactly $20 larger than the ASCII value of 2,
\ so this line outputs the `2DUP`.
n 'B l p n \ output TYPE 34 EMIT TYPE to finish the second program. Note the
\ that the final `n` introduces a trailing space. Trying to remove
\ it adds bytes.
```
To finish this off, I'd like to say that I tried using `EVALUATE`, but the second program becomes larger than both of the ones presented above. Anyway, here it is:
```
: s s" ; s evaluate"s" : l bl - ; : m l emit ; : d here $b $a - allot c! ; : c here swap dup allot move ; : q bl l do #tab emit dup @ bl l u.r cell+ #tab emit 'L m loop ; here bl 'B l 's bl 's bl 'Z l d d d d d d d -rot c bl 'B l 's 'B l d d d d s c 'B l d c 'e 'r 'e 'h m m m m 'A q #tab emit 'e 'p 'y 't m m m m"; s evaluate
```
If you manage to golf this down enough to outgolf my `s" ..."...` approach, go ahead and post it as your own answer.
[Answer]
# Perl, ~~(311+630 = 941 bytes)~~ 190+198 = 388 bytes
Both programs print to standard output.
The first perl program contains mostly printable ASCII characters and newlines, and it ends in exactly one newline, but the two letter ÿ represents the non-ASCII byte \xFF:
```
@f='^"ÿ"x92;@f=(@f,chr)for 115,97,121,36,126,191,153,194,216,113;print@f[1..5,5,10,5..9,0,9,0,5]'^"ÿ"x92;@f=(@f,chr)for 115,97,121,36,126,191,153,194,216,113;print@f[1..5,5,10,5..9,0,9,0,5]
```
The second one contains mostly non-ASCII bytes, including several high control characters that are replaced by stars in this post, and no newlines at all:
```
say$~~q~¿*ÂØ¡Ý*Ý*ÆÍÄ¿*Â׿*Ó***Ö***ßÎÎÊÓÆÈÓÎÍÎÓÌÉÓÎÍÉÓÎÆÎÓÎÊÌÓÎÆËÓÍÎÉÓÎÎÌÄ*****¿*¤ÎÑÑÊÓÊÓÎÏÓÊÑÑÆÓÏÓÆÓÏÓʢءÝ*Ý*ÆÍÄ¿*Â׿*Ó***Ö***ßÎÎÊÓÆÈÓÎÍÎÓÌÉÓÎÍÉÓÎÆÎÓÎÊÌÓÎÆËÓÍÎÉÓÎÎÌÄ*****¿*¤ÎÑÑÊÓÊÓÎÏÓÊÑÑÆÓÏÓÆÓÏÓÊ¢~
```
A hexdump of the first program with `xxd` is:
```
00000000: 4066 3d27 5e22 ff22 7839 323b 4066 3d28 @f='^"."x92;@f=(
00000010: 4066 2c63 6872 2966 6f72 2031 3135 2c39 @f,chr)for 115,9
00000020: 372c 3132 312c 3336 2c31 3236 2c31 3931 7,121,36,126,191
00000030: 2c31 3533 2c31 3934 2c32 3136 2c31 3133 ,153,194,216,113
00000040: 3b70 7269 6e74 4066 5b31 2e2e 352c 352c ;print@f[1..5,5,
00000050: 3130 2c35 2e2e 392c 302c 392c 302c 355d 10,5..9,0,9,0,5]
00000060: 275e 22ff 2278 3932 3b40 663d 2840 662c '^"."x92;@f=(@f,
00000070: 6368 7229 666f 7220 3131 352c 3937 2c31 chr)for 115,97,1
00000080: 3231 2c33 362c 3132 362c 3139 312c 3135 21,36,126,191,15
00000090: 332c 3139 342c 3231 362c 3131 333b 7072 3,194,216,113;pr
000000a0: 696e 7440 665b 312e 2e35 2c35 2c31 302c int@f[1..5,5,10,
000000b0: 352e 2e39 2c30 2c39 2c30 2c35 5d0a 5..9,0,9,0,5].
```
And a hexdump of the second program is:
```
00000000: 7361 7924 7e7e 717e bf99 c2d8 a1dd 00dd say$~~q~........
00000010: 87c6 cdc4 bf99 c2d7 bf99 d39c 978d d699 ................
00000020: 908d dfce ceca d3c6 c8d3 cecd ced3 ccc9 ................
00000030: d3ce cdc9 d3ce c6ce d3ce cacc d3ce c6cb ................
00000040: d3cd cec9 d3ce cecc c48f 8d96 918b bf99 ................
00000050: a4ce d1d1 cad3 cad3 cecf d3ca d1d1 c6d3 ................
00000060: cfd3 c6d3 cfd3 caa2 d8a1 dd00 dd87 c6cd ................
00000070: c4bf 99c2 d7bf 99d3 9c97 8dd6 9990 8ddf ................
00000080: cece cad3 c6c8 d3ce cdce d3cc c9d3 cecd ................
00000090: c9d3 cec6 ced3 ceca ccd3 cec6 cbd3 cdce ................
000000a0: c9d3 cece ccc4 8f8d 9691 8bbf 99a4 ced1 ................
000000b0: d1ca d3ca d3ce cfd3 cad1 d1c6 d3cf d3c6 ................
000000c0: d3cf d3ca a27e .....~
```
In the second program, the quoted string (189 bytes long, delimited by tildes) is the entire first program except the final newline, only encoded by bitwise complementing each byte. The second program simply decodes the string by complementing each of the bytes, which the `~` operator does in perl. The program prints the decoded string followed by a newline (the `say` method adds a newline).
In this construction, the decoder of the second program uses only six different ASCII characters, so the first program can be practically arbitrary, as long as it only contains ASCII characters and excludes those six characters. It's not hard to write any perl program without using those five characters. The actual quine logic is thus in the first program.
In the first program, the quine logic uses a 11 word long dictionary `@f`, and assembles the output from those words. The first words repeats most of the source code of the first program. The rest of the words are specific single characters. For example, word 5 is a tilde, which is the delimiter for the two string literal in the second program. The list of numbers between the brackets is the recipe for which words to print in what order. This is a pretty ordinary general construction method for quines, the only twist in this case is that the first dictionary words is printed with its bytes bitwise complemented.
[Answer]
# [Haskell](https://www.haskell.org/), 306 + 624 = 930 bytes
Program 1: An anonymous function taking a dummy argument and returning a string.
```
(\b c()->foldr(\a->map pred)b(show()>>c)`mappend`show(map(map fromEnum)$tail(show c):pure b))"İĴİóđđđÝöÝâÝæÝääē××êääē××İēÀħđĮâħēĕóİóòòĮááħááđéêâéêēááĮÀħ""(\b c()->foldr(\a->map pred)b(show()>>c)`mappend`show(map(map fromEnum)$tail(show c):pure b))"
```
[Try it online!](https://tio.run/##tY87asNAEIavsggVO4VygIDVmPSGNClUePWKTVbSspJI6ysYEVK5sBAWTmGME3yB2XN5M6vGJzDDP4@f@QZmJeqPTEpbiHU5U23z2ugn7nMAP7I8ilnCIQjzSqaaRyIIC6GY0lkKMa9X1SeHMExgSa7KynQ5WTQ4sVxXxUvZFuA3Yi2ndZbAs2p1xmIAz5zNnznjr9m6wB1eST3pQBpwMB1@U/zceyI63JiR9k/YU@3MF/F0Ay94IW@PezNOeYtHInuXiXHOyZGe99ifrL0luRTvtQ3e5ovFPw "Haskell – Try It Online")
Program 2: `q[[40,...]]` at the end is an anonymous function taking a dummy argument and returning a string.
```
z~z=[[['@','0'..]!!4..]!!z]
q[x,q]_=z=<<x++q++[34,34]++x
q[[40,92,98,32,99,40,41,45,62,102,111,108,100,114,40,92,97,45,62,109,97,112,32,112,114,101,100,41,98,40,115,104,111,119,40,41,62,62,99,41,96,109,97,112,112,101,110,100,96,115,104,111,119,40,109,97,112,40,109,97,112,32,102,114,111,109,69,110,117,109,41,36,116,97,105,108,40,115,104,111,119,32,99,41,58,112,117,114,101,32,98,41,41,34],[304,308,304,243,273,273,273,221,246,221,226,221,230,221,228,228,275,215,215,234,228,228,275,215,215,304,275,192,295,273,302,226,295,275,277,243,304,243,242,242,302,225,225,295,225,225,273,233,234,226,233,234,275,225,225,302,192,295]]
```
[Try it online!](https://tio.run/##bVHbSgQxDH3fv1gQRpmwNE0vU9gB/8HHMsg@CIqrOLrCMA/@@pik3Yu4D6dJ2nNO0vZ59/X6tN8vb7uX9/7j@/Bw@LyZbu@W@Wfuc87NfQONaTabYb12us7DaswTjMNjP/fb7dS2Y9tmckBuaNtpNfVjzs5AspA6IF4TcOkQnIdgAQ0DkWPHMJw7qPR4oiQpEK3oJQgJDaqAndjYidLzhitueOzC@lCaMi9ceinEBI0ayel/iwvB34qOs1c6n4RUzDBqyR1JPINKjNc7XhmUjvP5rg4WTzckfTZ5LZQXhUwsJPaRaB2BjRewyHuhRFsjmVp3BdGDxQr@pmv76s018i/Y5NWb@K7qqbUgav/THM4qCs8XJH/OZT6i2jOc83jmiLb2HIZl@QU "Haskell – Try It Online")
Character set 1 (includes space):
```
"$()-:>E\`abcdefhilmnoprstuw×ÝáâäæéêñòóöđēĕħĮİĴ
```
Character set 2 (includes newline):
```
!'+,.0123456789<=@[]_qxz~
```
Since only set 1 contains non-ASCII characters, their UTF-8 bytes are also disjoint.
# How it works
* Program 1 is generally written with lambda expressions, spaces and parentheses, free use of builtin alphanumeric functions, and with the quine data as string literals at the end.
+ Program 1's own core code is turned into string literal data simply by surrounding it with quote marks.
- To support this, every backslash is followed by `a` or `b`, which form valid escape sequences that roundtrip through `show`.
- Another tiny benefit is that `a`, `b` and `c` are the only lower case letters whose ASCII codes are less than 100, saving a digit in the numerical encoding used by program 2.
+ The string literal encoding of program 2's core code is more obfuscated by using non-ASCII Unicode: Every character has 182 added to its code point to ensure there is no overlap with the original characters.
- 182 used to be 128, until I realized I could abuse the fact that 182 is twice the length of the string literal for program 1's code to shorten the decoding. (As a bonus, program 2 can use newlines.)
* Program 2 is generally written with top level function equations (except for the final anonymous one), character literals and decimal numbers, list/range syntax and operators, and with the quine data as a list of lists of `Int`s at the end.
+ Program 1's core code is encoded as a list of its code points, with a final double quote.
+ Program 2's core code is encoded as the list of code points of the string literal used in program 1, still shifted upwards by 182.
# Walkthrough, program 1
* `b` and `c` are the values of the string literals for program 2 and 1, respectively, given as final arguments to the lambda expression. `()` is a dummy argument solely to satisfy PPCG's rule that the program should define a function.
* `foldr(\a->map pred)b(show()>>c)` decodes the string `b` to the core code of program 2 by applying `map pred` to it a number of times equal to the length of `show()>>c == c++c`, or `182`.
* `tail(show c)` converts the string `c` to the core code of program 1, with a final double quote appended.
* `:pure b` combines this in a list with the string `b`.
* `map(map fromEnum)$` converts the strings to lists of code points.
* ``mappend`show(...)` serializes the resulting list of lists and finally appends it to the core code of program 2.
# Walkthrough, program 2
* The toplevel `z~z=[[['@','0'..]!!4..]!!z]` is a function converting code points back to characters (necessary to write since not all the characters in `toEnum` are available.)
+ Its code point argument is also called `z`. The laziness marker `~` has no effect in this position but avoids a space character.
+ `['@','0'..]` is a backwards stepping list range starting at ASCII code 64, then jumping 16 down each step.
+ Applying `!!4` to this gives a `\NUL` character.
+ Wrapping that in a `[ ..]` range gives a list of all characters, which `!!z` indexes.
+ The character is finally wrapped in a singleton list. This allows mapping the function `z` over lists using `=<<` instead of the unavailable `map` and `<$>`.
* The toplevel `q[x,q]_=z=<<x++q++[34,34]++x` is a function constructing program 1 from the quine data list.
+ `x` is the data for the core of program 1 (including a final double quote) and the inner `q` is the obfuscated data for the core of program 2. `_` is another dummy argument solely to make the final anonymous function a function instead of just a string.
+ `x++q++[34,34]++x` concatenates the pieces, including two double quote marks with ASCII code 34.
+ `z=<<` constructs program 1 by mapping `z` over the concatenation to convert from code points to characters.
* The final `q[[40,...]]` is an anonymous function combining `q` with the quine data.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~128 90 87 86 85 79~~ 16 + 32 = 48 bytes
```
“OṾ⁾ọṙŒs”OṾ⁾ọṙŒs
```
[Try it online!](https://tio.run/##y0rNyan8//9Rwxz/hzv3PWrc93B378OdM49OKn7UMBdd6P9/AA "Jelly – Try It Online")
```
79,7806,8318,7885,7769,338,115ỌṘ
```
[Try it online!](https://tio.run/##y0rNyan8/9/cUsfcwsBMx8LY0ALIsjDVMTc3s9QxNrbQMTQ0fbi75@HOGf//AwA "Jelly – Try It Online")
The first program does the following:
```
“OṾ⁾ọṙŒs”OṾ⁾ọṙŒs
“OṾ⁾ọṙŒs” String literal: 'OṾ⁾ọṙŒs'
O ord: [79, 7806, 8318,...]
Ṿ Uneval. Returns '79,7806,8318,7885,7769,338,115'
⁾ọṙ Two character string literal: 'ọṙ'
Œs Swap case the two char literal: 'ỌṘ'.
```
This leaves the strings `79,7806,8318,7885,7769,338,115` and `ỌṘ` as the two arguments of the chain and they are implicitly concatenated and printed at the end.
The second program calculates the `chr` (`Ọ`) of the list of numbers which returns `OṾ⁾ọṙŒs`. `Ṙ` prints `“OṾ⁾ọṙŒs”` (with quotes) and returns the input, leaving `“OṾ⁾ọṙŒs”OṾ⁾ọṙŒs` as the full output.
[Answer]
# [Gol><>](https://github.com/Sp3000/Golfish), ~~23 + 23 = 46~~ ~~22 + 22 = 44~~ 20 + 20 = 40 bytes
```
"lF{3+|3d*HqlJJJQpp2
```
[Try it online!](https://tio.run/##S8/PScsszvj/XynHrdpYu8Y4RcujMMfLyyuwoMDo/38A "Gol><> – Try It Online")
```
'5ssTMMMotK-g6.6~Io
```
[Try it online!](https://tio.run/##S8/PScsszvj/X920uDjE19c3v8RbN92sXs@szjP//38A "Gol><> – Try It Online")
[Verify it online!](https://tio.run/##TY5NT4QwFEX3/RVPXAgOduHEWZgY48IvDAuNcV8ej7FJKdDXmiEw@tMruPKubm5uTo4L1RhjTQ1g2ubAmYAlLPFTOZZMhtDDBDPO0EptazoAwlGQrYVQOVRwA3dvjx9iWEqK6TplsFlgVQ4qy2SwehC6gUFS2/vx9g/fB8@QlMEHZcwIdEATWH/RSSLIMP373DvXuRyws43R6LXdw2qm0JPjazidhmOyysQYE/MwbTfztj5/GkxRFK99fxnPrpjfy7Ls/MvFfvcjd9/P3S8 "Ruby – Try It Online")
### How they work
```
"lF{3+|3d*HqlJJJQpp2
"..." Push everything to the stack
lF{3+| Add 3 to everything on the stack
3d* Push 39 `'`
H Print everything on the stack (from the top) and halt
'5ssTMMMotK-g6.6~Io
'...' Push everything to the stack
5ss Push 37 (34 `"` + 3)
T t Loop indefinitely...
MMMo Decrement 3 times, pop and print
At the end, `o` tries to print charcode -3, which is fishy (thanks Jo King)
Program terminates
```
Adapted from [Jo King's ><> answer](https://codegolf.stackexchange.com/a/153965/78410). Having many more alternative commands for output and repeat, there was no need for `g` or `p`, and the two main bodies became much shorter.
Another main difference is that I generate the opponent's quote directly at the top of the stack. This way, it was slightly easier to keep the invariant of `quote + my code + opponent code(reversed and shifted)`.
] |
[Question]
[
### Challenge
Given a polynomial \$p\$ with real coefficients of order \$1\$ and degree \$n\$, find another polynomial \$q\$ of degree at most \$n\$ such that \$(p∘q)(X) = p(q(X)) \equiv X \mod X^{n+1}\$, or in other words such that \$p(q(X)) = X + h(X)\$ where \$h\$ is an arbitrary polynomial with \$ord(h) \geqslant n+1\$. The polynomial \$q\$ is uniquely determined by \$p\$.
For a polynomial \$p(X) = a\_nX^n + a\_{n+1}X^{n+1} + ... + a\_m X^m\$ where \$n \leqslant m\$ and \$a\_n ≠ 0\$,\$a\_m ≠ 0\$, we say \$n\$ is the *order* of \$p\$ and \$m\$ is the *degree* of \$p\$.
**Simplification**: You can assume that \$p\$ has integer coefficients, and \$a\_1 = 1\$ (so \$p(X) = X + \text{[some integral polynomial of order 2]}\$). In this case \$q\$ has integral coefficients too.
The purpose of this simplification is to avoid the issues with floating point numbers. There is however a non-integral example for illustration purposes.
### Examples
* Consider the Taylor series of \$\exp(x)-1 = x + x^2/2 + x^3/6 + x^4/24 + ...\$ and \$\ln(x+1) = x - x^2/2 + x^3/3 - x^4/4 + ... \$ then obviously \$\ln(\exp(x)-1+1)= x\$.
If we just consider the Taylor polynomials of degree 4 of those two functions we get with the notation from below (see testcases) \$p = [-1/4,1/3,-1/2,1,0]\$ and \$q = [1/24, 1/6, 1/2, 1,0]\$ and \$(p∘q)(X) \equiv X \mod X^5\$
* Consider the polynomial \$p(X) = X + X^2 + X^3 + X^4\$. Then for \$q(X) = X - X^2 + X^3 - X^4\$ we get
$$(p \circ q)(X) = p(q(X)) = X - 2X^5 + 3X^6 - 10X^7 +...+ X^{16} \equiv X \mod X^5$$
### Testcases
Here the input and output polynomials are written as lists of coefficients (with the coefficient of the highest degree monomial first, the constant term last):
```
p = [4,3,2,0]; q=[0.3125,-.375,0.5,0]
```
Integral Testcases:
```
p = [1,0]; q = [1,0]
p = [9,8,7,6,5,4,3,2,1,0]; q = [4862,-1430,429,-132,42,-14,5,-2,1,0]
p = [-1,3,-3,1,0]; q = [91,15,3,1,0]
```
[Answer]
# Python 2 + sympy, 128 bytes
We locally invert the polynomial by assuming that q(x) = x, composing it with p, checking the coefficient for x2, and subtracting it from q. Let's say the coefficient was 4, then the new polynomial becomes q(x) = x - 4x2. We then again compose this with p, but look up the coefficient for x3. Etc...
```
from sympy import*
i=input()
p=Poly(i,var('x'));q=p*0+x
n=2
for _ in i[2:]:q-=compose(p,q).nth(n)*x**n;n+=1
print q.all_coeffs()
```
[Answer]
# Mathematica, 45 bytes
```
Normal@InverseSeries[#+O@x^(#~Exponent~x+1)]&
```
Yeah, Mathematica has a builtin for that....
Unnamed function taking as input a polynomial in the variable `x`, such as `-x^4+3x^3-3x^2+x` for the last test case, and returning a polynomial with similar syntax, such as `x+3x^2+15x^3+91x^4` for the last test case.
`#+O@x^(#~Exponent~x+1)` turns the input `#` into a power series object, truncated at the degree of `#`; `InverseSeries` does what it says; and `Normal` turns the resulting truncated power series back into a polynomial. (We could save those initial 7 bytes if an answer in the form `x+3x^2+15x^3+91x^4+O[x]^5` were acceptable. Indeed, if that were an acceptable format for both input and output, then `InverseSeries` alone would be a 13-byte solution.)
[Answer]
## JavaScript (ES6), 138 bytes
```
a=>a.reduce((r,_,i)=>[...r,i<2?i:a.map(l=>c=p.map((m,j)=>(r.map((n,k)=>p[k+=j]=m*n+(p[k]||0)),m*l+(c[j]||0)),p=[]),c=[],p=[1])&&-c[i]],[])
```
Port of @orlp's answer. I/O is in the form of arrays of coefficients in reverse order i.e. the first two coefficients are always 0 and 1.
[Answer]
# [Pari/GP](http://pari.math.u-bordeaux.fr/), 29 bytes
```
p->Pol(serreverse(p+O(x^#p)))
```
[Try it online!](https://tio.run/##LYrLDoJQDER/pcFNG9tExBcL@QXdE0xYXAwJwUkxRL/@CsJq5pwZ1N7aE7GhK0VYcX91PAT3MAYfAmN7489jAxGJNdB9GWQFwdv@zfMXQslsEmpWFlEqy4NmutddNfV0iVwvetaTHnXZVm3pRJb9sZL4Aw "Pari/GP – Try It Online")
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/195201/edit).
Closed 4 years ago.
[Improve this question](/posts/195201/edit)
Given an array where each number represent a color. After iterating each item in the array (for each item in the iteration the pointer can also point to the second-item-to-the-right), and the two colors in the iteration is the same, do the following checking:
If there is a different color between the pointed colors, the colors will "dissolve" (which is not allowed).
eg.: `[1,2,1]` is not allowed but `[1,1,2,2]` is allowed. Here is an explanation for the above test cases:
```
[1, 2, 1]
^ ^
```
We find that the two pointed items have the same color. We then realize that the color between the pointed items are different than the two same colors; this ensures a "dissolving".
The following is an explanation of the second example:
```
[1, 1, 2, 2]
^ ^
```
In this step, the atoms are different, so we don't perform the check.
```
[1, 1, 2, 2]
^ ^
```
In this step the atoms are still different. All colors do not "dissolve", ensuring a valid array.
---
We can change one color to another but the condition is if we change one color, then we have to change all of its occurrences in the array. The cost of changing color is the number of appearances of the color in the array.
eg.: if the array is `[1,2,1,2,1,3,2]` and we have decided to change 2 to 1, then our array will become `[1,1,1,1,1,3,1]` and the cost will be 3 (for changing three 2's to 1's)
We have to minimize the cost and make sure no color dissolves.
## Test cases
```
[1,1,3,3,2,2] -> 0 (no changes are required to prevent dissolving)
[1,3,1,3,1] -> 2 (change all 3's to 1's costs 2)
[1,1,2,3,2,3]-> 2 (change color of all 2's to 3's OR change color of all 3's to 2's)
[1,2,2,2] -> 0 (This is valid; in the second iteration, the color between the pointed colors are equal to the pointed colors.)
[1,2,1,2,1,3,2] -> 3 (the 1's must be changed to make the array valid, and there's 3 of them)
```
[Answer]
# [Perl 5](https://www.perl.org/), 92 bytes
```
sub f{min map{$o=$_;map{$s="@_";$c=!/$o/*$s=~s,$o,$_,g;$s=~/(.) (.) \1/&&$1-$2?9e9:$c}@_}@_}
```
[Try it online!](https://tio.run/##bVJNb@IwEL3zK2aRVRzWJRtHPZRsKJV63KpSRU8ERSEZiCUTp7GBVqj966ztsD3srhRL4@f3MTNKi528Oe81wi@hzXT6YoSE1yPdiSZIznq/hs3J1rAr2hNRKckTX@l0OM@HCSnTbyFR4dgCn5oRxUjOtom7hXQSgDtZFF5dkeia8LtbvJ2S8mOeu8@HLtCFPqoOwdhSp7ObZHCshUT68@F@cT8LTgOAMFvSyfguyFbZw5hm1fcgTCy8e6cE31o2F00bpJRwplspzIiNGImCngFkq0y6oZ7jIKGpxxh4LQyXJFrB9cyDQ7Ccj0Geu@w8Hywjxll/YsY9LQZaKm3gKKSENdr7RnVQ1kWzFc0WTN0hAh9pMAqikQ6ch1NbvXMA5/EDaKN6DWoo7PAdvu5Fh5VTtR0esDFQCa2VPFhXbxJ7m8hZeBNuG/EOUNhO4q9EcO1p4Jdk7pPj1d@iUknbt9p49aVfZ/L0DP9jXPz5ZSL@Zxr4mmhRC223C4dCiioB@8@YGkFjqZoKhMGuMEI1zKO99RrNEbHntUo0xs7vX/qd2JUU0oX@@z4Jzr8B "Perl 5 – Try It Online")
```
sub f{ #ungolfed:
min #minimum of the yielded list of numbers (from core module List::Util)
map{ #map: outer loop of f()'s input args
$o=$_; #keep $o (outer) loop element
map{ #map: inner loop of f()'s input args
$s="@_"; #$s string are input args (input chars) concatenated with no separation
$c=!/$o/*$s=~s,$o,$_,g; #$c becomes 0 if inner and outer loop elements are equal
#otherwise $c becomes the number of changes on the input
#$s string when swapping $o with $_ (outer and inner loop variable)
$s=~/(.) (.) \1/&&$1-$2 #check if $s after the swapping is valid: no three consecutive chars
#...should exists in $s where 1st and 3rd are equal but 2nd is not
? 9e9 #yield big number 9e9 if $s is invalid to make sure it wont be the minimum
: $c #yield the number of swaps if $s is valid
}
@_ #input arg's
}
@_ #input arg's, outer loop
}
```
] |
Subsets and Splits