text
stringlengths 180
608k
|
|---|
[Question]
[
May be you know [the game of Set](http://www.setgame.com/set/daily_puzzle) (a wonderful game for kids btw) a card game with 81 cards, where each card has a figure on it with 4 different attributes (form , number, colour and fill). Each attribute has 3 different values:
```
form: wave, oval, diamond
colour: red, purple, and green
number: 1, 2, 3
fill: none, dashed, opaque.
```
12 cards are laid open on the table and now the challenge is to indicate sets. A set consists of three cards where every attribute value occurs 0, 1 or 3 times. having 2 cards with red figures, or opaque, or 1 number is no good. See the [supplied](http://www.setgame.com/set/daily_puzzle) link for a more visual explanation.
I do envision a code for a card where all attributes are encoded so
```
"WP2N"
```
stands for
```
2 Purple Waves with No fill
```
Together with for instance `OR1N` and `DG3N`
 and 
it is a set (3 different forms, 3 different colors, 3 different number, 1 fill).
Input is space delimited string of unique codes (randomly chosen out of 81 possible codes) representing cards.
```
"OR1N WP2N DG3N DR1D WG3S WG1N WR2D WP3N DR2O DR2D OG3O OR2D"
```
The solution must indicate all possible sets within the given collection. So
```
OR1N, WP2N, DG3N
```
must be part of the solution together with all other sets.
[Answer]
# Mathematica ~~93 92 93 82 76~~ 73
```
f={}⋃Select[StringSplit@#~Subsets~{3}, FreeQ[Tally/@(Characters@#^T),2]&]&
```
**The Logic**
`StringSplit@#~Subsets~{3}` produces a list of 3-card subsets. Each triple such as:
{{"D", "G", "3", "N"}, {"W", "G", "3", "S"}, {"O", "G", "3", "O"}}
or
is then transposed,
and `Tally/@(Characters@#^T)` tallies the number of distinct items in each row.
```
{3,1,1,3}
```
3 corresponds to "all different"; 1 corresponds to "all same".
`FreeQ[...,2]` determines whether 2 cards of the same type or in the triple.
If 2 is not among the tallies, then the three cards are a "set", according to Game of Set rules.
---
**Usage**
```
f["OR1N WP2N DG3N DR1D WG3S WG1N WR2D WP3N DR2O DR1D OG3O OR2D"]
```
>
> {{"DG3N", "WG3S", "OG3O"}, {"OR1N", "WP2N", "DG3N"}, {"WP2N", "DR1D",
> "OG3O"}}
>
>
>
[Answer]
## Ruby, ~~104~~ ~~98~~ ~~81~~ 80 characters
```
$*.combination(3).map{|c|puts c*?,if(0..3).all?{|i|c.map{|x|x[i]}.uniq.size!=2}}
```
Sample run (using your example data):
```
c:\a\ruby>set.rb OR1N WP2N DG3N DR1D WG3S WG1N WR2D WP3N DR2O DR1D OG3O OR2D
OR1N,WP2N,DG3N
WP2N,DR1D,OG3O
WP2N,DR1D,OG3O
DG3N,WG3S,OG3O
```
It outputs `WP2N,DR1D,OG3O` twice because you have two `DR1D`s in your sample data.
Explanation:
`$*.combination(3).map{|c|` - each combination of 3 cards
`puts c*?,if` - output the set, if...
`(0..3).all?{|i|` - if all of the numbers from 0 to 3 (the indeces of the properties in the string) evaluate to `true` when passed into this block
`c.map{|x|x[i]}` - take the `i`th index of each string
`.uniq.size!=2}` - if the amount of unique properties (form, color, etc.) is not 2 (so, 1 or 3)
[Answer]
# Mathematica 73
```
f = Select[StringSplit@#~Subsets~{3}, FreeQ[Tally /@ Thread@Characters@#, 2] &] &
```
**Usage**
```
f["OR1N WP2N DG3N DR1D WG3S WG1N WR2D WP3N DR2O DR1D OG3O OR2D"]
```
>
> {{"OR1N", "WP2N", "DG3N"}, {"WP2N", "DR1D", "OG3O"}, {"WP2N", "DR1D", "OG3O"}, {"DG3N", "WG3S", "OG3O"}}
>
>
>
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 12 bytes
```
ṇ₁⊇Ṫz{=|≠}ᵐz
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/pfXa7EVQOEYUoPd3XaP2rb8Kip6eG2BUDOw60THnUsf7hjG5BdC@T8f7iz/VFT46Ou9oc7V1VV29Y86lwAEq/6/z9ayT/I0E8hPMDIT8HF3RhIBBm6KIS7GwcDCZBEkBGQGwCWMPIHES4K/u7G/gr@QJaSjpJxcUGGglFKUaqCYX5BMZBIzwASRUCx4nQwF0iAZYtBEilArlEKWEl6qlIsAA "Brachylog – Try It Online")
Takes input through the input variable and [generates](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods/10753#10753) the output through the output variable.
Second test case taken from a [recently closed duplicate](https://codegolf.stackexchange.com/questions/195023/play-the-card-game-set) in its encoding, since this solution doesn't really care what anything actually means.
```
The output variable is
⊇ a subsequence
Ṫ of length 3
ṇ₁ of the input split on spaces,
z z the columns of which
{ }ᵐ are all
| either
= the same element repeated,
≠ or entirely free of duplicates.
```
[Answer]
### GolfScript, 53 characters
```
" "/:w,,{:a,{:^,{a^]{w=}%.0\zip{.&,2=|}/!{.p}*;}/}/}/
```
Input must be provided on STDIN, [example online](http://golfscript.apphb.com/?c=OyJPUjFOIFdQMk4gREczTiBEUjFEIFdHM1MgV0cxTiBXUjJEIFdQM04gRFIyTyBEUjJEIE9HM08gT1IyRCIKCiIgIi86dywsezphLHs6Xix7YV5de3c9fSUuMFx6aXB7LiYsMj18fS8hey5wfSo7fS99L30vCg%3D%3D&run=true):
```
> OR1N WP2N DG3N DR1D WG3S WG1N WR2D WP3N DR2O DR2D OG3O OR2D
["OR1N" "DG3N" "WP2N"]
["WP2N" "OG3O" "DR1D"]
["DG3N" "OG3O" "WG3S"]
["WR2D" "OR2D" "DR2D"]
```
Commented code:
```
" "/:w # split the input at spaces and assign it to variable w
,, # create the array [0..n-1] (n being the length of w)
{:a,{:^,{ # three nested loops: a=0..n-1, ^=0..a-1, _=0..b-1
# (third loop has no variable assigned but just pushes on stack)
a^] # make an array [a,^,_] of the three loop variables
{w=}% # take the corresponding list items, i.e. [w[a],w[^],w[_]]
.0\ # push zero, add duplicate of the the array
zip # zip transposes the array, thus [OR1N WP2N DG3N] -> [OWD RPG 123 NNN]
{ # loop over those entries
.& # unique
,2= # length equals 2?
| # "or" with top of stack (two zero pushed before)
}/ # end of loop, on stack remains the results of the "or"s
!{.p}* # if no length of 2 is there, make a copy of the set and print it
; # discard stack item
}/}/}/ # closing the three nested loops
```
[Answer]
## javascript ~~323~~ 313
```
function a(b){d=h=[];c=e=f=0;for(i in b){for(j in b){for(k in b[i]){if(b[i][k]==b[j][k]){if(c+f<4)c++;else if(c==4){h+=b[j];if(h.length=3)return h}}else{for(l in d){for(m in d[l]){g=f;if(d[l][2]==i){if(d[l][3]==k)if(b[j][k]!=d[l][0]&&b[j][k]!=d[l][1])f++;}else{continue}}if(g==f)d[e++]=[b[i][k],b[j][k],j,k]}}}}}}
```
its a function that takes a array of objects, and returns a array of objects.
[DEMO fiddle](http://jsfiddle.net/mendelthecoder/uQeMy/3/) (with tidy-up).
[Answer]
## APL(IBM), 76
```
⍉¨x/⍨{{⍵≡1⌽⍵}⍵=1⌽⍵}¨x←⊃¨(∘.,/3⍴⊂⍪¨(' '≠y)⊂y←⍞)⌷⍨¨z/⍨∧/¨2</¨z←,⍳3⍴12
```
I don't have IBM APL, but I believe this will work.
**Sample run (Emulating IBM APL in Dyalog APL)**
```
OR1N WP2N DG3N DR1D WG3S WG1N WR2D WP3N DR2O DR1D OG3O OR2D
OR1N WP2N WP2N DG3N
WP2N DR1D DR1D WG3S
DG3N OG3O OG3O OG3O
```
[Answer]
## Sage, 71
If `C` is a string, say `"OR1N WP2N DG3N DR1D WG3S WG1N WR2D WP3N DR2O DR1D OG3O OR2D"`, execute
```
[c for c in Subsets(C.split(),3)if{1,3}>={len(set(x))for x in zip(*c)}]
```
to get `[{'DR1D', 'OG3O', 'WP2N'}, {'DR2D', 'WR2D', 'OR2D'}, {'WG3S', 'OG3O',
'DG3N'}, {'DG3N', 'WP2N', 'OR1N'}]`
And here's a very different approach using the interpretation that a Set is a projective line in `GF(3)^4`:
```
[c for c in Subsets(C.split(),3)if sum(matrix(3,map('WODRPG123N'.find,''.join(c))))%3==0]
```
I was a little annoyed that `D` was used twice... until I figured how to abuse that. But even better, I abuse the `find` method, too. `str.find` returns -1 if a letter isn't found. Since `-1 = 2 mod 3`, the letter `S` is handled appropriately because it doesn't occur in `'WODRPG123N'`.
[Answer]
# [Python 2](https://docs.python.org/2/), 99 bytes
```
lambda A:[a for a in combinations(A,3)if all(len(set(t))-2for t in zip(*a))]
from itertools import*
```
[Try it online!](https://tio.run/##HYqxCsIwFEV3v@LhlBQVmmyCQ6HQrSl16KAOqTb4IE1C8hb9@Zq4HO7lnPCht3diM5f7ZvU6vzQ055sG4yNoQAdPv87oNKF3iTUHydGAtpbZxbG0ECPOj6LUVOovBlZpzh87E/0KSEsk720CXIOPVG0hoiMwbK/GuodpED20ncwY6xamTl4zihhFvsNfCFXQguqkApXX/pSCRWKcbz8 "Python 2 – Try It Online")
] |
[Question]
[
Here is a simple, bite-sized (byte-sized?) code golf: given a non-empty list of positive integers less than 10, print a [block-diagonal](http://en.wikipedia.org/wiki/Block_matrix#Block_diagonal_matrices) matrix, where the list specifies the size of the blocks, in order. The blocks must consist of positive integers less than 10. So if you're given as input
```
[5 1 1 2 3 1]
```
Your output could be, for instance,
```
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
0 0 0 0 0 1 0 0 0 0 0 0 0
0 0 0 0 0 0 1 0 0 0 0 0 0
0 0 0 0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 0 0 0 1
```
or
```
1 2 3 4 5 0 0 0 0 0 0 0 0
6 7 8 9 1 0 0 0 0 0 0 0 0
2 3 4 5 6 0 0 0 0 0 0 0 0
7 8 9 1 2 0 0 0 0 0 0 0 0
3 4 5 6 7 0 0 0 0 0 0 0 0
0 0 0 0 0 8 0 0 0 0 0 0 0
0 0 0 0 0 0 9 0 0 0 0 0 0
0 0 0 0 0 0 0 1 2 0 0 0 0
0 0 0 0 0 0 0 3 4 0 0 0 0
0 0 0 0 0 0 0 0 0 5 6 7 0
0 0 0 0 0 0 0 0 0 8 9 1 0
0 0 0 0 0 0 0 0 0 2 3 4 0
0 0 0 0 0 0 0 0 0 0 0 0 5
```
or something like that. The elements in the matrix must be separated by (single) spaces, and the rows separated by (single) newlines. There must not be leading or trailing spaces on any lines. You may or may not print a trailing newline.
You may write a function or program, taking input via STDIN (or closest alternative), command-line argument or function argument, in any convenient string or list format (as long as it isn't preprocessed). However, the result must be printed to STDOUT (or closest alternative), as opposed to returned from a function, say.
You must not use any built-in functions designed to create block-diagonal matrices.
This is code golf, so the shortest submission (in bytes) wins.
# Leaderboards
I expect the array-based languages (like J and APL) to have the edge here, but I don't want that to discourage people from trying to do as well as they can in their language of choice. So here is a Stack Snippet to generate both a regular leaderboard and an overview of winners by language. So why not try and grab a spot on the latter?
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
```
```
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 getAnswers(){$.ajax({url:answersUrl(page++),method:"get",dataType:"jsonp",crossDomain:true,success:function(e){answers.push.apply(answers,e.items);if(e.has_more)getAnswers();else process()}})}function shouldHaveHeading(e){var t=false;var n=e.body_markdown.split("\n");try{t|=/^#/.test(e.body_markdown);t|=["-","="].indexOf(n[1][0])>-1;t&=LANGUAGE_REG.test(e.body_markdown)}catch(r){}return t}function shouldHaveScore(e){var t=false;try{t|=SIZE_REG.test(e.body_markdown.split("\n")[0])}catch(n){}return t}function getAuthorName(e){return e.owner.display_name}function process(){answers=answers.filter(shouldHaveScore).filter(shouldHaveHeading);answers.sort(function(e,t){var n=+(e.body_markdown.split("\n")[0].match(SIZE_REG)||[Infinity])[0],r=+(t.body_markdown.split("\n")[0].match(SIZE_REG)||[Infinity])[0];return n-r});var e={};var t=0,c=0,p=-1;answers.forEach(function(n){var r=n.body_markdown.split("\n")[0];var i=$("#answer-template").html();var s=r.match(NUMBER_REG)[0];var o=(r.match(SIZE_REG)||[0])[0];var u=r.match(LANGUAGE_REG)[1];var a=getAuthorName(n);t++;c=p==o?c:t;i=i.replace("{{PLACE}}",c+".").replace("{{NAME}}",a).replace("{{LANGUAGE}}",u).replace("{{SIZE}}",o).replace("{{LINK}}",n.share_link);i=$(i);p=o;$("#answers").append(i);e[u]=e[u]||{lang:u,user:a,size:o,link:n.share_link}});var n=[];for(var r in e)if(e.hasOwnProperty(r))n.push(e[r]);n.sort(function(e,t){if(e.lang>t.lang)return 1;if(e.lang<t.lang)return-1;return 0});for(var i=0;i<n.length;++i){var s=$("#language-template").html();var r=n[i];s=s.replace("{{LANGUAGE}}",r.lang).replace("{{NAME}}",r.user).replace("{{SIZE}}",r.size).replace("{{LINK}}",r.link);s=$(s);$("#languages").append(s)}}var QUESTION_ID=45550;var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";var answers=[],page=1;getAnswers();var SIZE_REG=/\d+(?=[^\d&]*(?:<(?:s>[^&]*<\/s>|[^&]+>)[^\d&]*)*$)/;var NUMBER_REG=/\d+/;var LANGUAGE_REG=/^#*\s*([^,]+)/
```
```
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>Language<td>Size<tbody id=answers></table></div><div id=language-list><h2>Winners by Language</h2><table class=language-list><thead><tr><td>Language<td>User<td>Score<tbody id=languages></table></div><table style=display:none><tbody id=answer-template><tr><td>{{PLACE}}</td><td>{{NAME}}<td>{{LANGUAGE}}<td>{{SIZE}}<td><a href={{LINK}}>Link</a></table><table style=display:none><tbody id=language-template><tr><td>{{LANGUAGE}}<td>{{NAME}}<td>{{SIZE}}<td><a href={{LINK}}>Link</a></table>
```
[Answer]
# J, 7 bytes
Thanks for [FUZxxl](https://codegolf.stackexchange.com/users/134/fuzxxl) for the 2-byte improvement.
Array based languages should be counted here in a different competition as they have a huge advantage. :)
```
=/~@#<\
(=/~@#<\) 3 1 1 2
1 1 1 0 0 0 0
1 1 1 0 0 0 0
1 1 1 0 0 0 0
0 0 0 1 0 0 0
0 0 0 0 1 0 0
0 0 0 0 0 1 1
0 0 0 0 0 1 1
```
Another 7-byte approach:
```
#]=@##\
```
Explanation for the old version `([:=/~]#<\)`:
The first step is generating `n` piece of similar things (e.g. numbers) for every list element `n`. These should be different from the other elements'. E.g. using the natural numbers `3 1 1 2` becomes `0 0 0 1 2 3 3`.
To save on bytes we use the boxed prefixes of the list:
```
]#<\ 3 1 1 2
┌─┬─┬─┬───┬─────┬───────┬───────┐
│3│3│3│3 1│3 1 1│3 1 1 2│3 1 1 2│
└─┴─┴─┴───┴─────┴───────┴───────┘
```
With the `=/~` verb we create a table of Descartes products of these boxed prefixes and each cell will be `1` if the two entries are equal `0` otherwise.
[Answer]
# APL, 10
```
∘.=⍨∆/⍋∆←⎕
```
Example:
```
∘.=⍨∆/⍋∆←⎕
⎕:
5 1 1 2 3 1
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
0 0 0 0 0 1 0 0 0 0 0 0 0
0 0 0 0 0 0 1 0 0 0 0 0 0
0 0 0 0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 0 0 0 1
```
Explanation:
* `∆←⎕`: read input, store in `∆`.
* `⍋∆`: find permutation that sorts `∆` (this gives an unique value for each value in the input)
* `∆/`: for each of those unique values, repeat it `N` times, where `N` is the corresponding value in the input
* `∘.=⍨`: make a matrix comparing each value in that list to the other values.
[Answer]
# R, ~~69~~ 63
```
function(x)write(+outer(i<-rep(1:length(x),x),i,"=="),1,sum(x))
```
Test Case:
```
(function(x)write(+outer(i<-rep(1:length(x),x),i,"=="),1,sum(x)))(c(5,1,1,3,1))
1 1 1 1 1 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0
0 0 0 0 0 1 0 0 0 0 0
0 0 0 0 0 0 1 0 0 0 0
0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 0 1
```
The outer function does most of the work here, then its just a case of getting the output looking right - Thanks to @Vlo for his help with that
[Answer]
# Python 3, ~~103~~ ~~97~~ ~~82~~ ~~78~~ 76 bytes
```
def P(L,n=0):k,*L=L;exec("print(*[0]*n+[1]*k+[0]*sum(L));"*k);L and P(L,n+k)
```
Using splat to take advantage of the space-separating nature of `print`, with a bit of recursion.
[Answer]
# Ruby, ~~86~~ ~~90~~ 83 bytes
My first golf ever!
```
->l{n=l.reduce :+;s=0;l.map{|x|x.times{puts ([0]*s+[1]*x+[0]*(n-x-s))*" "};s+=x}}
```
Receives an array with the integers, prints the expected result:
```
$ (->l{n=l.reduce :+;s=0;l.map{|x|x.times{puts ([0]*s+[1]*x+[0]*(n-x-s))*" "};s+=x}}).call([5, 1, 1, 2, 3, 1])
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
0 0 0 0 0 1 0 0 0 0 0 0 0
0 0 0 0 0 0 1 0 0 0 0 0 0
0 0 0 0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 0 0 0 1
```
**Edit:**
Thanks to Martin Büttner for helping me shortening some things!
[Answer]
# Matlab, ~~60~~ 54 bytes
This would be Matlab's special field *IF* we could use builtin functions...
Thanks @sanchises for fixing the error I missed.
```
c=0;a=input('');for A=a;v=c+1:c+A;d(v,v)=1;c=c+A;end;d
```
[Answer]
# Matlab, 53 bytes
Though it is only one char shorter than the other Matlab fragment, I figured the code is sufficiently different to warrant a new answer:
```
d=[];a=input('');for A=a;v=1:A;d(end+v,end+v)=1;end;d
```
The main trick is of course out of bounds indexing, but this is combined with using `end` as a variable to make it more compact.
[Answer]
# [APL (Dyalog Extended)](https://github.com/abrudz/dyalog-apl-extended), 6 bytes
```
∘.=⍨⍸⎕
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNrShJzUtJTfn/qKM9DUjM0LN91LviUe@OR31TQWL/07hMFQyB0EjBWMGQK40LwjIBAA "APL (Dyalog Extended) – Try It Online")
A full program that takes the input vector from stdin and prints the matrix.
---
If a function returning a matrix were allowed:
# [APL (Dyalog Extended)](https://github.com/abrudz/dyalog-apl-extended), 5 bytes
```
∘.=⍨⍸
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNrShJzUtJTfn//1HHDD3bR70rHvXu@J/2qG3Co96@R31TPf0fdTUfWm/8qG0ikBcc5AwkQzw8g/@nKZgqGAKhkYKxgiEA "APL (Dyalog Extended) – Try It Online")
APL wins back against J and K with the extended domain for `⍸`.
### How it works
```
∘.=⍨⍸
⍸ ⍝ Where; convert to an array that,
⍝ for each element n at index i, has n copies of i
∘.=⍨ ⍝ Outer product by element-wise equality on self
```
[Answer]
# CJam, 21
```
q~{T):Ta*~}%_f{f=S*N}
```
Try it at <http://cjam.aditsu.net/>
**Explanation:**
```
q~ read and evaluate the input array
{…}% transform each number using the block
T):T increment T (initially 0)
a* wrap T in an array and repeat it <number> times
~ dump the repeated numbers so they end up in a flat array
_ duplicate the array
f{…} for each array item and the array
f= compare the current item with each item, resulting in an array of 1 and 0
S* join with spaces
N add a newline
```
[Answer]
# Python 3, 79
```
def f(l,s=0):
for x in l:r=[0]*sum(l);r[s:s+x]=[1]*x;s+=x;exec("print(*r);"*x)
```
Tracks the leftmost index of the block as `s` and makes the `x` entries after it be `1`, where `x` is the current block size. This row is then printed `x` times. Python 3 is needed to do `print(*r)`.
[Answer]
# Haskell, 118 116 bytes
```
(#)=replicate
f i=putStr$[e#(unwords$sum h#"0"++e#"1"++sum t#"0")|(h,e:t)<-map(`splitAt`i)[0..length i-1]]>>=unlines
```
Usage: `f [2,1,1,3]`
Output:
```
1 1 0 0 0 0 0
1 1 0 0 0 0 0
0 0 1 0 0 0 0
0 0 0 1 0 0 0
0 0 0 0 1 1 1
0 0 0 0 1 1 1
0 0 0 0 1 1 1
```
How it works:
```
[0..length i-1] for each index n of the input list i
(h,e:t)<-map(`splitAt`i) split i at n and
let e be the element at index n
let h be the list of elements to the left of e
let t be the list of elements to the right of e
foreach triple h, e, t make a list of
sum h # "0" ++ sh copies of "0" (sh = the sum of the elements of h) followed by
e # "1" ++ e copies of "1" followed by
sum t # "0" st copies of "0" (st = the sum of the elements of t)
unwords join those list elements with spaces inbetween
e # make e copies
>>=unlines join those lists with newlines inbetween
putStr print
```
[Answer]
# [K (ngn/k)](https://codeberg.org/ngn/k), 12 bytes
```
5:'=/:/2#,&:
```
[Try it online!](https://ngn.bitbucket.io/k#eJxLszK1UrfVt9I3UtZRs+LiSlMwUjAEQmNrINMQyDFWMLEGAIiaBt4=)
`5:` is "debug print". Since the default formatting of a matrix is not what is wanted here, it is printed row-wise via `'`.
---
if function returning a matrix (list of lists) were allowed:
# [K (ngn/k)](https://codeberg.org/ngn/k), 9 bytes
```
=/:/2#,&:
```
[Try it online!](https://ngn.bitbucket.io/k#eJxLs7LVt9I3UtZRs+LiSlMwUjAEQmMgyxDINlYwAQBl1AXS)
Took almost two years to golf a byte from [the previous ngn/k answer](https://codegolf.stackexchange.com/a/194793/78410) :P
The algorithm itself is the same. The problem with making something a train is that you're allowed to reference the input only once. This code solves the problem by making `=/:` reduce over the two copies of the vector `&x`.
[Answer]
# Pyth, ~~23~~ 21 bytes
[GitHub repository for Pyth](https://github.com/isaacg1/pyth)
```
Ju+G*]GHQYFNJjdmsqdNJ
```
Input is a list of integers, like `[3, 1, 1, 2]`. Try it online: [Pyth Compiler/Executor](https://pyth.herokuapp.com/)
Uses a quite similar idea as randomra's J code. The first part of the code `Ju+G*]GHQY` generates `n` parts of similar things. For the example input `[3, 1, 1, 2]` the result looks like this:
```
[
[],
[],
[],
[[], [], []],
[[], [], [], [[], [], []]],
[[], [], [], [[], [], []], [[], [], [], [[], [], []]]],
[[], [], [], [[], [], []], [[], [], [], [[], [], []]]]
]
```
First three identical elements, than one element , then one element again and at the end two identical elements.
```
Ju+G*]GHQY
u QY reduce the input Q, start with empty list G=[]
for each H in input, replace the value of G by:
+G*]GH G+[G]*H
J store the result in J
```
The second part of the code is comparing the elements of the Cartesian product and printing it.
```
FNJjdmsqdNJ
FNJ for N in J:
m J map each element d of J to
qdN the boolean value of d == N
s and convert it to an integer (0 = False, 1 = True)
jd print the resulting list seperated by d (=space)
```
[Answer]
# C++ , 294 bytes
[*Compiler used - GCC 4.9.2*](http://ideone.com/c869XT)
```
#include<bits/stdc++.h>
using namespace std;
#define F(a,b) for(a=0;a<b;a++)
#define V vector<int>
int n,i,j,s,o;
main(){V v;while(cin>>n)v.push_back(n),s+=n;vector<V> m(s,V(s,0));F(i,v.size()){F(j,v[i])F(n,v[i])m[j+o][n+o]=1;o+=v[i];}F(j,s){F(n,s)cout<<m[j][n]<<((n==s-1)?"":" ");cout<<"\n";}}
```
Explanation -:
```
#include<bits/stdc++.h>
using namespace std;
#define F(a,b) for(a=0;a<b;a++)
#define V vector<int>
int n, i, j, s, o;
/*
n = Used to take inputs, and as an iterator after that
i, j = Iterators
s = sum of all the inputs
o = offset ( used to find the location of the starting cell of the next matrix of 1's )
*/
main()
{
V v;
while ( cin >> n ) // Take input
{
v.push_back( n ), s += n;
}
vector<V> m( s, V( s, 0 ) ); // m is a matrix of size (s*s) with all elements initialized to 0
F( i, v.size() )
{
F( j, v[i] )F( n, v[i] )m[j + o][n + o] = 1; // Assign 1 to the required cells
o += v[i]; // Add the value of the current element to the offset
}
F( j, s ) // Output the matrix
{
F( n, s )cout << m[j][n] << ( ( n == s - 1 ) ? "" : " " ); // Prevent any trailing whitespace
cout << "\n";
}
}
```
[Answer]
# K, 30 bytes
```
{"i"$,/x#',:',/'g=\:\:x#'g:<x}
```
Basically stole marinus's answer
```
k){"i"$,/x#',:',/' g=\:\:x#'g:<x}5 1 1 2 3 1
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
0 0 0 0 0 1 0 0 0 0 0 0 0
0 0 0 0 0 0 1 0 0 0 0 0 0
0 0 0 0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 0 0 0 1
```
[Answer]
# Java, 163
```
a->{int n=a.stream().mapToInt(x->x).sum(),t=0,j,k;for(int i:a){for(j=0;j++<i;System.out.println("\b"))for(k=0;k<n;)System.out.print(k>=t&k++<t+i?"1 ":"0 ");t+=i;}}
```
A consumer which accepts a list of integers.
Readable version, with boilerplate code:
```
java.util.function.Consumer<java.util.List<Integer>> c = a -> {
int n = a.stream().mapToInt(x -> x).sum(), t = 0, j, k;
for (int i : a) {
for (j = 0; j++ < i; System.out.println("\b")) {
for (k = 0; k < n;) {
System.out.print(k >= t & k++ < t + i ? "1 " : "0 ");
}
}
t += i;
}
};
```
Invoke using:
```
List list = Arrays.asList(5, 1, 1, 2, 3, 1);
c.accept(list);
```
[Answer]
# Python 2, ~~163~~ 114 bytes
gnibbler golfed this a bunch.
```
h=input()
r=range
l=len(h)
for i in r(l):
for k in r(h[i]):print" ".join("01"[i==j]for j in r(l)for x in r(h[j]))
```
[Answer]
# Python 3, 74
```
def f(a,p=0):n=a.pop(0);exec("print(*'0'*p+'1'*n+'0'*sum(a));"*n);f(a,p+n)
```
[Answer]
# JavaScript (ES6), 103 ~~107~~
103 bytes as an anonymous function, not counting `F=` (but you need this to test it)
```
F=l=>alert(l.map((n,y)=>(l.map((n,x)=>Array(n).fill(x==y|0))+'\n').repeat(n))
.join('').replace(/,/g,' '))
```
**Test** In Firefox/FireBug console
```
F([5,1,1,2,3,1])
```
*Output*
```
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
0 0 0 0 0 1 0 0 0 0 0 0 0
0 0 0 0 0 0 1 0 0 0 0 0 0
0 0 0 0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 0 0 0 1
```
[Answer]
# Octave, ~~49~~ 41 bytes
```
@(a)(c=repelems(b=1:length(a),[b;a]))'==c
```
[Answer]
# Pyth, ~~31~~ 30
```
FbQVbjd++*]0Z*b]b*]0--sQbZ)~Zb
```
A pretty naive program, takes the input on stdin. This can probably be golfed more ;)
Thanks @Jakube for pointing out a wasted char
[Try it here](https://pyth.herokuapp.com/)
[Answer]
# Perl, 69
```
#!perl -na
$j=s/./0 x$&/ger;print+($j|$i.1x$_)=~s/\B/ /gr x($i.=0 x$_,$_)for@F
```
Uses standard input:
```
$ perl a.pl <<<"1 2 3"
1 0 0 0 0 0
0 1 1 0 0 0
0 1 1 0 0 0
0 0 0 1 1 1
0 0 0 1 1 1
0 0 0 1 1 1
```
[Answer]
# R, ~~117~~ ~~144~~ ~~137~~ ~~133~~ ~~129~~ 123 bytes
Reasonably verbose at the moment. Should be able to shave a few more out. Gained a number of bytes formatting it correctly, but saved some swapping out the matrix for an array.
Thanks to Alex for the tip on the replacing sep with s and removing the function name.
Dropped the array completely and used a series of reps to build each line.
Although soundly beaten by Miff, his solution made me realise I could drop the s=' ' altogether.
```
function(i){s=sum(i);i=cumsum(i);b=0;for(n in 1:s){d=i[i>=n][1];cat(c(rep(0,b),rep(1,d-b),rep(0,s-d)),fill=T);if(d==n)b=d}}
```
And the test
```
> (function(i){s=sum(i);i=cumsum(i);b=0;for(n in 1:s){d=i[i>=n][1];cat(c(rep(0,b),rep(1,d-b),rep(0,s-d)),fill=T,s=' ');if(d==n)b=d}})(c(5,1,1,3,1))
1 1 1 1 1 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0
0 0 0 0 0 1 0 0 0 0 0
0 0 0 0 0 0 1 0 0 0 0
0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 0 1
>
```
[Answer]
## Batch - 226 Bytes
```
@echo off&setLocal enableDelayedExpansion&set c=0&for %%a in (%*)do set/ac+=1&for /l %%b in (1,1,%%a)do (set l=&set d=0&for %%c in (%*)do (set/ad+=1&for /l %%d in (1,1,%%c)do if !d!==!c! (set l=!l!1)else set l=!l!0)
echo !l!)
```
Takes input from stdin (`C:\>script.bat 5 1 1 2 3 1`) and echo's output. Unfortunately I couldn't get that last echo on the same line, otherwise I could probably call the whole line within `cmd/von/c` to avoid having to enable delayed expansion the long way.
Nice and neat - nothing but grunt work:
```
@echo off
setLocal enableDelayedExpansion
set c=0
for %%a in (%*) do (
set /a c+=1
for /l %%b in (1,1,%%a) do (
set l=
set d=0
for %%c in (%*) do (
set /a d+=1
for /l %%d in (1,1,%%c) do if !d!==!c! (set l=!l!1) else set l=!l!0
)
echo !l!
)
)
```
[Answer]
# Haskell, 124
```
(%)=replicate
d l=fst$foldr(\x(m,n)->(m>>mapM_(\_->putStrLn$unwords$n%"0"++x%"1"++(sum l-n-x)%"0")[1..x],n+x))(return(),0)l
```
Produces output by combining IO actions through `mapM_` and `foldr`. The function `d` should be given a list of ints.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 7 bytes
```
ĖŒṙ⁼þ`G
```
[Try it online!](https://tio.run/##y0rNyan8///ItKOTHu6c@ahxz@F9Ce7///831TEEQiMdYx1DAA "Jelly – Try It Online")
Same approach as the J answer.
```
G Grid format
⁼þ a table of whether or not pairs of elements are equal, from
Œṙ the run-length decoded
Ė enumeration of the input,
` compared with itself.
```
[Answer]
# [Julia 1.6](https://julialang.org), 68 bytes
```
>(L,c=0)=((x,l...)=L;print(("0 "^c*"1 "^x*"0 "^sum(l)*"
")^x);l>c+x)
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m700qzQnM3HBgqWlJWm6Fjdd7DR8dJJtDTRtNTQqdHL09PQ0bX2sC4oy80o0NJQMFJTikrWUDIFUhRaYV1yaq5GjqaXEpaQZV6FpnWOXrF2hCTFrq51GtKmOgiEYGekoGAMZsVA5mH0A)
port of [Sp3000's answer](https://codegolf.stackexchange.com/a/45564/98541)
needs julia 1.6 for `x,l...=L`
output as a matrix would save a lot of bytes but printing it as expected uses more bytes:
`!L=(l=[(a=1;L.|>i->(a+=1)ones(i))...;]).==l'` [(44bytes)](https://ato.pxeger.com/run?1=m700qzQnM3HBgqWlJWm6Fjd1FH1sNXJsozUSbQ2tffRq7DJ17TQStW0NNfPzUos1MjU19fT0rGM19Wxtc9QhevalZBYX5CRWaihqRJvqKBiCkZGOgjGQEaupCVEEswAA)
[Answer]
# [Uiua](https://uiua.org), 20 bytes
4 bytes for constructing the array; 16 bytes for formatting the output :/
```
≡(&p↘1/⊂)∵⊂@ +@0⊞=.⊚
```
[Try it online!](https://www.uiua.org/pad?src=QmxvY2tEaWFnIOKGkCDiiaEoJnDihpgxL-KKginiiLXiioJAICtAMOKKnj0u4oqaCkJsb2NrRGlhZyBbNSAxIDEgMiAzIDFdCg==)
## Explanation
```
⊞=.⊚ # construct the table in the same way as other array languages
+@0 # convert numbers to characters
/⊂ ∵⊂@ # interleave spaces (including leading space)
↘1 # remove said leading space
≡(&p ) # and print each line
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 7 bytes
```
żẋf:v=⁋
```
[Try it Online!](https://vyxal.pythonanywhere.com/?v=2&c=1#WyIiLCIiLCLFvOG6i2Y6dj3igYsiLCIiLCJbNSwxLDEsMiwzLDFdIl0=) -1 byte thanks to lyxal.
Same approach as a lot of the array-language answers
```
ẋ # Repeat elements of
ż # [1...len(input)
ẋ # By numbers in the input
f # Flatten
:v= # Table by equality
⁋ # Format as grid
```
[Answer]
# K (ngn/k), 14 bytes:
[`{5:'x=\:x:&x;}`](https://ngn.bitbucket.io/k#eJxLs6o2tVKvsI2xqrBSq7Cu5eJKUzBWMFQwVTDmAgBx9gbV)
fixed. now prints to stdout
] |
[Question]
[
In Excel, the columns range from `A-Z, AA,AB,AZ,BA,..,BZ` and so on. They actually each stand for numbers, but rather are encoded as alphabet strings.
In this challenge, you will be given a string of alphabets, and you must calculate the column it corresponds to.
Some tests:
>
> 'A' returns 1 (meaning that it is the first column)
>
>
> 'B' returns 2
>
>
> 'Z' returns 26
>
>
> 'AA' returns 27
>
>
> 'AB' returns 28
>
>
> 'AZ' returns 52
>
>
> 'ZZ' returns 702
>
>
> 'AAA' returns 703
>
>
>
You can assume that capital letters will be given only.
Shortest bytes win.
Good luck!
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 17 bytes
```
{:26[.ords X-64]}
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYKvwv9rKyCxaL78opVghQtfMJLb2f3FipUKahpKjkqY1F5TthMSOQmI7IityRFbliKwsClUPWNN/AA "Perl 6 – Try It Online")
Anonymous code block that subtracts 64 from each byte value and converts from base 26 with `Z` overflowing to the next column.
[Answer]
# Google Sheets, 21 bytes
(formula evaluates to the result, takes input from cell A1)
```
=column(indirect(A1&2
```
[Answer]
# [R](https://www.r-project.org/), ~~48~~ 43 bytes
-5 bytes thanks to @Giuseppe, using the same logic, but as a program that eliminates the `nchar` call.
```
for(i in utf8ToInt(scan(,"")))F=F*26+i-64;F
```
[Try it online!](https://tio.run/##K/r/Py2/SCNTITNPobQkzSIk3zOvRKM4OTFPQ0dJSVNT083WTcvITDtT18zE2u2/o6PjfwA "R – Try It Online")
[Answer]
# [Java (JDK)](http://jdk.java.net/), 39 bytes
```
s->s.chars().reduce(0,(a,b)->a*26+b%32)
```
[Try it online!](https://tio.run/##ZY89a8MwEIZ3/4rDYJBSW5SUdkgagzoUOnRKp5QO8lcq15aMdA6E4t/uSrLJ0kEn7rn3HqRWXETWVj@z7AdtEFrXsxFlxzb76B9rRlWi1MoPo7IT1sK7kAp@I4BhLDpZgkWB7rpoWUHvZuSIRqrz5xcIc7Y0RAE@9JvC19X2vERyaOAw2yy3rPwWxhLKTF2NZU3uUyLSgma52Gyf7orkYUvnffDc5FhbtHBY9QAxj1OIX3w5@cJDzwPggZxWzuOwMi3CRhtYnxycu8VMb@Lj1WLdMz0iG1wKGxInj3YHSZUoJ/TpFBomhqG7cut@STyidNFPkT/T/Ac "Java (JDK) – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), ~~52~~ 45 bytes
```
t=0
for c in input():t=26*t+ord(c)%64
print t
```
[Try it online!](https://tio.run/##JYyxCsJADIbn5imyyLW6SJEOhQ5XqKuLi930Gmmp9I6Qon3686KQ/ycfH0nYZPRLGZ0fCBs0xkRpjvD0jA6nJU1YJS9qacpqLwfPQ@6KXXWCwNMiKDFdALzH6UV45ZVqyIS31Bl9yOX6toC0OwqC3eXcMXtW/WC6z9FYA6ZN6VOsglWyiq1if9P6259O/gs "Python 2 – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 6 bytes
```
Çžx-₂β
```
[Try it online!](https://tio.run/##yy9OTMpM/f//cPvRfRW6j5qazm36/z8qCgA "05AB1E – Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), ~~38~~ ~~34~~ 31 bytes
```
foldl(\o->(o*26-64+).fromEnum)0
```
[Try it online!](https://tio.run/##y0gszk7NyfmfZhvzPy0/JyVHIyZf104jX8vITNfMRFtTL60oP9c1rzRX0@B/bmJmnoKtQkFRZl6JgopCmoKSo6PS/3/JaTmJ6cX/dZMLCgA "Haskell – Try It Online")
[Answer]
# PHP, ~~41~~ 38 bytes
-3 thanks to Jo King.
```
for($c=A;$c!=$argn;$i++)$c++;echo$i+1;
```
run as pipe with `-nr`
unary output, 34 bytes:
```
1<?for($c=A;$c!=$argn;$c++)echo 1;
```
requires PHP 7.1. save to file, run as pipe with `-nF`.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 7 bytes
```
ØAiⱮḅ26
```
[Try it online!](https://tio.run/##y0rNyan8///wDMfMRxvXPdzRamT2//9/R0dHAA "Jelly – Try It Online")
[Answer]
# APL(NARS), 11 chars, 22 bytes
```
{+/26⊥⎕A⍳⍵}
```
test
```
f←{+/26⊥⎕A⍳⍵}
f¨'A' 'AA' 'AAA'
1 27 703
f¨'AB' 'ZZ' 'Z'
28 702 26
```
[Answer]
# [J](http://jsoftware.com/), 11 bytes
```
26#.64|3&u:
```
[Try it online!](https://tio.run/##y/qvpKegnqZga6WuoKNQa6VgoADE/43MlPXMTGqM1Uqt/mtypSmoO6qDyBAwGQUmHSFUFJTn6Kj@HwA "J – Try It Online")
### How it works
```
26#.64|3&u: Monadic verb. Input: a string.
3&u: Convert each character to Unicode codepoint
64| Modulo 64; maps A -> 1, ... Z -> 26
26#. Interpret as base-26 digits and convert to single integer
```
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 48 bytes
```
f=([h,...t],p=0)=>h?f(t,p*26+parseInt(h,36)-9):p
```
[Try it online!](https://tio.run/##JcjRCsIgFIDhx/Gc5SQKBhUu3F2vsLELWZqLpYcpsbe3SRf/xfe/9VfHaZ0p1T48Tc5WwuC4ECKNnOQRZevuFhKn6tQcSK/RPHwCx88N1he8Ur5NwcewGLGEFwxMMc66vX5PFagiVdj/n2Kj@GiCTbYWNkTMPw "JavaScript (Node.js) – Try It Online")
[Answer]
# [APL (Dyalog Classic)](https://www.dyalog.com/), 11 bytes
```
⎕A∘⍳⊥⍨26⍴⍨≢
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNzkksLs5M/v8/7VHbhEd9Ux0fdcx41Lv5UdfSR70rjMwe9W4B0o86FwEVKKg7qnMBSScwGQUmHSFCjhAxR4hgFEzOUR0A "APL (Dyalog Classic) – Try It Online")
[Answer]
# [J](http://jsoftware.com/), 20 bytes
```
[:(#.~26$~#)32|a.i.]
```
[Try it online!](https://tio.run/##y/qfVmyrp2CgYKVg8D/aSkNZr87ITKVOWdPYqCZRL1Mv9r8ml5KegnqarZ66go5CrZVCWjEXV2pyRr5CmoK6ozqc6YRgRiGYjkgqHJGUOCKpiUJR76j@HwA "J – Try It Online")
## Explanation:
```
[:(#.~26$~#)32|a.i.]
i. - indices
] - of the characters of the input
a. - in the alphabet
32| - mod 32
[:( ) - apply the following code to the above
$~ - create a list of (left and right arguments exchanged)
26 - the number 26
# - repeated the length of the input times
#.~ - to base (26)
```
[Answer]
# Google Sheets, 100 bytes
(formula evaluates to the result, takes input from cell A1)
```
=sum(arrayformula(
(
code(
mid(A1,row(indirect("1:"&len(A1))),1)
)-64
)*26^row(indirect("1:"&len(A1)))/26
```
All spaces are added for clarity only.
*Note*.
* I don't know if it's possible to remove the duplication of `row(indirect("1:"&len(A1))`.
* Although Google Sheets has a `decimal` function, the transliteration would takes a lot of bytes.
[Answer]
# APL+WIN, 12 bytes
Index origin 1.
```
26⊥¯65+⎕av⍳⎕
```
[Try it online! Courtesy of Dyalog Classic](https://tio.run/##SyzI0U2pTMzJT9dNzkksLs5M/v@ob6qvz6O2CcZcjzra0/4bmT3qWnpovZmpNlAisexR72Yg/R8o9T@NS93R0VEdAA "APL (APL+WIN) – Try It Online")
Explanation:
```
⎕av⍳⎕ Prompts for input and gets Ascii integer value for each character
¯65+ subtracts 65 to give integers 1-26 for A-Z
26⊥ converts resulting vector from base 26 to single integer
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 10 bytes
```
Ｉ↨²⁶ＥＳ⊕⌕αι
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMM5sbhEwymxOFXDyExHwTexQMMzr6C0JLgEKJuuoamj4JmXXJSam5pXkpqi4ZaZl6KRqKOQqQkG1v//Ozr91y3LAQA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
Ｓ Input string
Ｅ Map over characters
ι Current character
α Uppercase alphabet
⌕ Find index
⊕ Increment
²⁶ Literal 26
↨ Base conversion
Ｉ Cast to string
Implicitly print
```
[Answer]
# [Java (JDK)](http://jdk.java.net/), 92 bytes
```
static int m(String v){int x=0;for(int i=0;i<v.length();i++)x=x*26+v.charAt(i)-64;return x;}
```
[Try it online!](https://tio.run/##fZCxboMwEIbn@ilOTHZRUBpVWRwGZ@yajaqDQyi5FAyyjUUV8ezEBKdTgyXLd7rP@n7dRTq5upx@RsgraQx8@F60bYW5tNiotzVcCQGA6ULbHf0AjPWzHFyDJ6glKnqwGlX5@QVSl4b5HxDOXLwcfo0t6qTpbNJ60laKRiKN4to/EWOc/EvsZ2L/nMhmIntOiIdmwSOCSCyYRFCJBVf2iLOY5y/QPRGQgQAZw0Y9BHXYJjh2nfo@XfPvRtOpRl/jziVVoUp7poxjHLM@7V8329gl@VlqYSmy1fad68J2WkHPh3EYbw "Java (JDK) – Try It Online")
**Output**
>
> A=1
>
>
> B=2
>
>
> Z=26
>
>
> AA=27
>
>
> AB=28
>
>
> AZ=52
>
>
> ZZ=702
>
>
> AAA=703
>
>
>
[Answer]
# [MATL](https://github.com/lmendo/MATL), 11 bytes
```
0w"26*@+64-
```
[Try it online!](https://tio.run/##y00syfn/36BcychMy0HbzET3/391R0dHdQA "MATL – Try It Online")
[Answer]
# [Kotlin](https://kotlinlang.org), 36 bytes
```
{it.fold(0){o,n->o*26+n.toInt()-64}}
```
[Try it online!](https://tio.run/##LYyxCsIwFEV3v@KR6UXbIiIdihbi5uTg1i0gKcH0paRPQUK@PbbVOxy4h8t9enaW8ls7MA3eOVjqZdleieEMOVqujHcP3MvoCypbvz3UO6rYzwOUZX1MKZsXwaAtoQ791IAKQX9Ov6dWxg3McXbim0GhRAHisqBboNauVqFW0/29ErIa9AhxnG/YERq0LGXapPwF "Kotlin – Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/), 18 bytes
```
->s{[*?A..s].size}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1664OlrL3lFPrzhWrzizKrX2f4FCWrSSo1IsF4QBZP0HAA "Ruby – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~46~~, 43 bytes
```
a;f(int*s){for(a=0;*s;)a=*s++%64+a*26;s=a;}
```
[Try it online!](https://tio.run/##Zc1Na8JAEAbgs/6KYUTYTRRsqrG4LGUFC6JQ8OMiXpZ0VwIaJSO0EPLXu66hWoyXObzPzLxJd5ckzmlhWZqdA@KFPeZMy54ISHAtAwrDdtwPdRDFgqQWpWt9GZtmBtRyOVmsmPk5cWCFv4bcEEioEnHKfWIZKiKTn6FNI8CWF9xm2LluvuPnDEf4oabz9WKCXJS8edBpxnjRbPz9tmyOCjkASOnHCxcPNP6nqEabO0VxjVT1saJhncZ3eqvT5kaDp64bDXvRU9e1rKJXT6X7Texe78h1vy8 "C (gcc) – Try It Online")
## Degolf
```
a; f(int*s)
{ for(a=0;*s;) // Loop through s, which is a null-terminated string.
a=*s++%64 + a*26; // Multiply accumulated value by 26, and add current char modulo 64 to it.
s=a;} // Return the accumulated value.
```
[Answer]
# [Ahead](https://github.com/ajc2/ahead), 22 bytes
```
>jvi'@-\26l
^~>O@ ~+*<
```
[Try it online!](https://tio.run/##S8xITUz5/98uqyxT3UE3xsgshyuuzs7fQaFOW8vmf1ppnkJuYmaeRmJRerGVgmNRUWKlTXBJUWZeup2mQjWXAhCUJeYoJOfnKNgqaBQBzfLJzEvV0FSwt1JQUtIEKygAKi/RACopzc0DUZqaXLX/HR0dAQ "Ahead – Try It Online")
[Answer]
## [MBASIC](https://archive.org/details/BASIC-80_MBASIC_Reference_Manual), 84 bytes
```
1 INPUT S$:L=LEN(S$):FOR I=1 TO L:V=ASC(MID$(S$,I,1))-64:T=T+26^(L-I)*V:NEXT:PRINT T
```
Output:
```
? AZ
52
? ZZ
702
? AAA
703
```
[Answer]
# x86 machine code, 19 bytes
```
00000000: 31c0 8b19 83e3 3f41 b21a f7e2 01d8 3831 1.....?A......81
00000010: 75f0 c3 u..
```
Assembly:
```
section .text
global func
func: ;this function uses fastcall conventions
xor eax, eax ;reset eax to 0
loop:
;ebx=*ecx%64
mov ebx, [ecx] ;ecx is 1st arg to this func (in fastcall conventions)
and ebx, 63 ;because 64 is a pwr of 2,n%64=n&(64-1)
;ecx++ get next char in str by incrementing ptr
inc ecx
;eax=eax*26
mov dl, 26 ;using an 8bit reg is less bytes
mul edx
;eax+=ebx //(eax=(*ecx%64)+(eax*26))
add eax, ebx
;if(*ecx!='\0')goto loop
cmp byte [ecx], dh ;dh==0
jne loop
ret ;return value is in eax
```
[Try it online!](https://tio.run/##bVRRb5swEH6GX3GL2gJJSNI0yrZQKrVap73tvSWKjDGEjtjINilVmt@enR22JVORML677@6@O59JiVofKNFwe/v48zvcwVhv6jEZEbWBCLj5hDmr8pvpqSUUR4mKjI0EAhldC/BYq5nksFoRrWWZNpqtVr6fE6UpqaoggJJryBtOfbomsh9EG1JyP9hZSTOln5fxrnffG/bu7fKAy9OTFVGe7KNcSN/EKONJZPHlMioHg6CWqM393qVawGWW8N6wsw5ttk4Igmjv/SlR6SYd0ShxE7eg9LwirPcUdFZryEVYlwzCzc3Ueov0JWs2NYTfznCYJmNbjJAxKc@B6gz4DpqxUzBqCskQ9wje8yT8utzN9uChljYawhQ@h7Pph15aQpiBl3Dvn2AdLdSkbNtspFsN769YMUULef0F3s62Dy6ux9O9gR@7Cb2E9/v9hzfNgIqG6wVKCb9U2F648M3MhMEHZdpRCFnn/oO1pmjcLXpwdzWNADlAiOTq/ygZgwEk7tlBHBSjuhQcRhrHy3WKSqSkslPkmmXh4BPpdamszkIbxVDqxg7J8y3jxqBcpxUSGGmHZkE/yRTTZg9awMR1KiHqhYsGlrZxn9H2cj5DcSO2gJohPKNqiVbaAia8VhqILIzvXwKAA/ph7gDjEJ4d48xvnChllCBTmM9MLAL1qwSRw3TIMWnMr/z5LLwOXMuGtoOB4xTIlWMXwFwYvEyg8JTTN9xRyTYmDy@g1hJdUIWXssWd9SdtjG9/Ou@KyaohTOdO1CjjQjh8SUsNkhWGSsWUwrB4awy6qYBlJ4EGMVYA47Fvgvpdj4KBf4wf2DKzrGty2lr@ZW6Bn2IvmXhBIbBhptNoonghTKpjZ4eQrSHK1nGMZ@G8cNbBJNOOPS3d4P9lS6qGGaLYAUxzwB/X4Tc "Try It Online")
[Answer]
# Japt `-h`, 10 bytes
```
åÈ*26+InYc
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.6&code=5cgqMjYrSW5ZYw==&input=IkFBQSIKLWg=)
Or without a flag. The first byte can be removed if we can take input as a character array.
```
¨c aI̓26
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.6&code=rK5jIGFJw+wyNg==&input=IkFBQSI=)
---
## Explanation
```
åÈ :Cumulatively reduce by passing each character at Y through a function, with an initial total of 0
*26 : Multiply current total by 26
-I : Subtract 64
n : Subtracted from
Yc : The codepoint of Y
:Implicitly output the last element of the resulting array
```
[Answer]
# [Kotlin](https://kotlinlang.org), 29 bytes
```
{it.fold(0){a,v->v-'@'+a*26}}
```
[Try it online!](https://tio.run/##LY7NCoJAFEb3PsWHG@dWRrRoIWnNMmjXE1zyh6HxGtMohPjsk2Xf5mwOh@/ReWskDGxx72zfSgZ1885IQ0gLXMQjD6Px27qzpdrRyJshLYY0OSdrXu0P0xTqXtCyEcWueWXQzvH7uDQKwhhh3r@PHMpVXF6NVIpwyhDH9BOes@7VcuELomgKWusP "Kotlin – Try It Online")
## Explained
```
val column: (String) -> Int = { // String in, Int out
it.fold(0) { a, v -> // acc, value
v - '@' // distance of char from @ (A=1 etc.)
+ a * 26
}
}
```
[Answer]
# [Ruby](https://www.ruby-lang.org/) `-nl`, 39 bytes
```
p$_.chars.reduce(0){|x,y|26*x+y.ord-64}
```
[Try it online!](https://tio.run/##KypNqvz/v0AlXi85I7GoWK8oNaU0OVXDQLO6pkKnssbITKtCu1IvvyhF18yk9v9/Ry4nriguR0cuRycuxyiuKBDb8V9@QUlmfl7xf928HAA "Ruby – 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/192889/edit).
Closed 4 years ago.
[Improve this question](/posts/192889/edit)
Given:
* a 12 hour time `t` in hours and minutes,
* a rotation `r` in degrees,
return the time shown when an analog clock that is displaying the time `t` is rotated `r` degrees clockwise.
After rotation, the hour hand will not line up with the new position of the minute hand. To correct for this, the new hour can be derived from the new position of the hour hand.
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"). The shortest solution wins. Standard loopholes apply.
Inspired by unmarked analog clocks like this one: ![Unmarked analog clock]](https://i3.cpcache.com/merchandise/49_550x550_Front_Color-NA.jpg)
]
|
[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/189559/edit).
Closed 4 years ago.
[Improve this question](/posts/189559/edit)
Create a function that takes in a generator function as its only parameter, and returns an object that can be used as both as a [generator](https://beta.developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Generator) and a [generator function](https://beta.developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function*) for said generator. The idea is to be able to create an object that behaves like a generator (that is, it follows the [iteration protocols](https://beta.developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols)) but also has the ability to restart itself.
For the rules:
* `SelfGenerator` is the function you're creating.
* `sg` is the return value of `SelfGenerator`.
* `genFunc` is the parameter passed into `SelfGenerator`.
**Rules:**
* `sg` must have a `start` method that returns a generator that behaves the same as the generator that would be returned by `genFunc`.
* `sg.start` must accept parameters that will be used to create the generator it returns such that it is the same as the generator returned by passing those parameters into `genFunc`.
* After `sg.start(...params)` has been executed, if `genFunc(...params)[prop]` is callable, then `sg[prop]` is also callable and will return the same value.
* `sg.start(...params).next(value); let a = sg.next();` and `sg.start(...params); sg.next(value); let a = sg.next();` must end up with the same value for `a`.
* smallest source code wins
**Example:**
```
let sg = SelfGenerator(function*(n) {
yield n;
yield n + 1;
yield n + 2;
});
sg.start(1); // Generator
sg.next(); // {value: 1, done: false}
sg.next(); // {value: 2, done: false}
sg.start(10).next(); // {value: 10, done: false}
sg.next(); // {value: 11, done: false}
```
]
|
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
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).
Closed 4 years ago.
[Improve this question](/posts/187849/edit)
Problem: We have a two dimensional matrix of positive integer cells. On each turn any non-zero cell with a neighbor (top/bottom/left/right) of zero decreases by 1. We want count to the number of non-zero cells present and add them up across all turns.
Is there a faster solution than to use a priority queue?
Is there a name for this problem or a similar problem? I don’t know what to search for.
## Example
Here is an input where the result is 7:
```
00000
00100
01210
00100
00000
```
Initially there are 5 non-zero cells.
```
00000
00000
00200
00000
00000
```
After the first turn, there is 1 non-zero cell.
```
00000
00000
00100
00000
00000
```
After the second turn, there is still 1 non-zero cell.
```
00000
00000
00000
00000
00000
```
After the third turn, there are 0 non-zero cells.
If we total these up:
\$5 + 1 + 1 = 7\$
Our result is \$7\$
]
|
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
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).
Closed 4 years ago.
[Improve this question](/posts/186303/edit)
I'm stuck on a problem involving the [Gale-Ryser Theorem](https://en.wikipedia.org/wiki/Gale%E2%80%93Ryser_theorem). The problem's input gives me the row-wise sum of an hv-convex binary matrix(n\*m).
```
e.g. I get {4,3,2,2,1} in the input. It's the row wise sum of the following matrix:
1 1 1 1
1 1 1 0
1 1 0 0
1 1 0 0
1 0 0 0
```
To solve the problem, I have to find the row-wise sum of it's transpose.
```
i.e. I need to calculate {5,4,2,1}
1 1 1 1 1
1 1 1 1 0
1 1 0 0 0
1 0 0 0 0
```
Can it be achieved in less than O(n\*m)?
---
**I got the answer [here](https://cs.stackexchange.com/questions/110116/finding-row-wise-sum-of-transpose-of-hv-convex-binary-matrix).**
]
|
[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/181701/edit).
Closed 4 years ago.
[Improve this question](/posts/181701/edit)
If I need to get the number of diagonal squares in all directions:
![Queen on E4 with its diagonals traced outwards[1]](https://i.stack.imgur.com/Y5H9Z.png)
I do the following formula `2 N − 2 − |x − y| − |x + y − N − 1|`
The above example has **13** and that's what the formula gives.
Now, what if you wanted to get the diagonal squares, but only in one direction?
The top right has **4** squares, the top left has **3**, the bottom left has **3** and the bottom right has **3**.
Assume I have that program to compute all legal diagonals for the *Queen*, and as I demonstrated above I can get all diagonals by one step using above formula, written like :
```
int positiveDiagonal = Math.abs(r_q - c_q);
int negativeDiagonal = Math.abs(r_q + c_q - n - 1);
int totalDiagonal = 2 * n - 2 - positiveDiagonal - negativeDiagonal;
```
So, assume there is a soldier on position **(5,5)**, that's make the *Queen* can't move to others diagonals in the same direction with total **4** count.
Sample Input - 1:
* Board length = 8
* Queen on position **(4, 4)**
* There is no soldiers.
* Explanation :
+ Because there is no pieces (*soldiers*), we just get all diagonals we calculated using our formula.
Output - 1: **13**
---
Sample Input - 2:
* Board length = 8
* Queen on position **(4, 4)**
* There is a soldiers on point **(5, 3)**
* Explanation :
+ Because there is a piece or whatever, on point **(5, 3)**, The Queen can't go to **(5, 3)**, **(6, 2)** and **(7, 1)**.
Output - 2: The total diagonals we got from formula is **13** and by calculating the soldier diagonals [The steps that queen can't go through], the result would be **10**.
---
Sample Input - 3:
* Board length = 5
* Queen on position **(5, 5)**
* There is a soldiers on point **(1, 1)**
* Explanation :
+ Because there is a piece (*soldier*), on point **(1, 1)**, The Queen can't go to that square.
Output - 3: By subtracting this **square** from total diagonals which equal **4** it's results **3**
---
Sample Input - 4:
* Board length = 5
* Queen on position **(3, 3)**
* Soldiers on positions **(5, 5)** , **(2, 1)**, and **(4, 4)**
* Explanation :
+ Because there is a piece (*soldier*), on point **(5, 5)** and **(4, 4)**, The Queen can't go to these squares.
Output - 4 = **6**
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~41~~ 37 bytes
```
æ.µṬ+ḢṬ$+⁴²x@0¤s⁴µŒD;UŒD$ṣ€1Ẏ=2Ẹ$ƇF¬S
```
[Try it online!](https://tio.run/##y0rNyan8///wMr1DWx/uXKP9cMciIKWi/ahxy6FNFQ4Gh5YUg5hbj05ysQ4FEioPdy5@1LTG8OGuPlujh7t2qBxrdzu0Jvj////RxjrGsTrRpjqmQNJIxxBImuiYxP43BQA "Jelly – Try It Online")
A dyadic link that takes as its left argument the zero-indexed positions of the queen and any soldiers as a list (queen first, any subsequent entries a solider) and as right argument the board size. Returns an integer that represents the number of squares available for moves on the diagonal.
### Explanation
```
æ. | dot product of piece positions with board size, right-padded with 1
µ | start new chain with this as input
Ṭ | make a boolean array with 1 at the position of each piece
+ḢṬ$ | and add the same again for the Queen so the Queen has a 2
+⁴²x@0¤ | expand to the board dimension square with zeroes
s⁴ | split into lists the length of the board dimension
µ | start a new chain
ŒD;UŒD$ | concatenate the diagonals and the diagonals of the flipped board
ṣ€1 | split at soldiers
Ẏ | tighten (make a single list of lists)
=2Ẹ$Ƈ | filter keeping only those diagonals with the Queen in
F¬S | count the number of zeroes
```
] |
[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/179730/edit).
Closed 5 years ago.
[Improve this question](/posts/179730/edit)
Sorry folks, but what I've got for you today is a golf but just limited by JS (or, to be strict, for a day of posting - an ES6 - the most modern set of it - if its ES7 - feel free to EDIT! use MOST MODERN features).
So if you afford that restriction - let's proceed!
Assume we have JSON root data structure `r` and some global ID `g=0`:
```
g=0;r={i:g++,x:0,c:[]}
```
This creates a root `r` of a data tree, indexed by unique index `i`, with a data payload `x`, where we (for simplicity) let `x` to be always zero, and child array `c` where `c[j]` just an object of same syntax, as `r` its own. Sorry for extra data `x`, indeed, we will don use it ever! Our goal is to do golfed **ID lookup** method!
My grandfather implementation was quite a mess... Just imagine, in his times people named functions with more than one symbol! Just like that:
```
find_subid = (id, childVec) => {
for( child of childVec ) {
found = find_id( id, child );
if( found ) // 200
return found;
}
return null; // 404
}
find_id = (id, parent) => (id == parent.i) ? parent : find_subid(id, parent.c);
```
Now I can call `find_id(123,g)` but.. I just feel that's too long to write today!
So we should fix his errors and do our own, faster, harder and **shorter** version in most possible modern JS as of the time you are reading this text!
]
|
[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 5 years ago.
[Improve this question](/posts/179626/edit)
As you may or may not know, Valentine's day is getting close. So today, my task for you is:
# Write a heart-shaped quine
Rules:
* Code should look like an identifyable heart shape, i.e. Has two round parts on top and a pointy bottom. It does NOT have to be filled in, but this is not disallowed.
* Standard Quine rules apply (no opening/reading files, etc)
* This is a [popularity-contest](/questions/tagged/popularity-contest "show questions tagged 'popularity-contest'"), so try to be as creative as possible in your solutions!
---
The closing date will be the day **after** valentine's day (15th of February), 12:00 UTC
]
|
[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/177049/edit).
Closed 5 years ago.
[Improve this question](/posts/177049/edit)
Write a program that, given a string of capital letters, output all possible phrases that could have been written originally, using any variant of the Oxford English Dictionary.
## Input
There are two inputs:
* A string \$s\$ of A-Z capital letters that is a phrase with certain letters removed. Example: `THSSANEAMPLE`
* Another string \$r\$ of the letters that have been removed from said phrase. Example: `IX`. These letters are in no particular order.
## Output
Output all phrases shorter than twice the length of \$s\$ which, after removing letters in \$r\$, result in \$s\$. Separate words in each phrase by spaces.
## Rules
* You are allowed to access any webpage you want, as long as it was created before this question was originally asked. If this webpage was changed in order to facilitate this challenge, then this is likewise not acceptable.
* Slang or names of places or people are not required.
* Disregard whether a phrase would be syntactically or grammatically correct.
* Assume that any full word containing only omitted letters is not to be included.
## Examples
"MITURE","X" should only have one possibility.
"MN", "DAI" should give you "MAN", but need not give "ADMIN", "MIND", or "DAMN" because they're at least twice as long as "MN".
]
|
[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/167675/edit).
Closed 5 years ago.
[Improve this question](/posts/167675/edit)
The one dimensional [twitter waterflow problem](https://chrisdone.com/posts/twitter-problem-loeb) is this:
You are given an array that represents a hill in the sense that the ith entry is the height of the ith location of the hill. When it rains, water logs in the hills, and you need to figure out how much water would log.
For example, after raining, the array `2 5 3 4 3 2 5 5 3 4 2 2 2` looks like this,
and 9 units of water have accumulated.
---
The challenge is to solve the 2D version of this. To clarify, you will be given a 2D matrix of land heights, and you will have to output the total amount of rainwater it can collect. Water cannot flow out through diagonals, but only the four cardinal directions.
[Answer]
# [Python 3](https://docs.python.org/3/), ~~O(h × w × d)~~ 296 bytes, O(h × w × d')
```
def f(a):
w=0;b=[len(a[0])*[0]];a=b+a+b;a=[[0]+x+[0]for x in a];b=sorted(set(sum(a,[])))
for[i,j]in zip(b,b[1:]+[1+max(b)]):
c=[[0,0]]
while c:
[x,y]=c.pop()
if x<len(a)and x>=0and y<len(a[0])and y>=0and a[x][y]<=i:w+=i-a[x][y];a[x][y]=j;c+=[[x+1,y],[x,y+1],[x-1,y],[x,y-1]]
return w
```
[Try it online!](https://tio.run/##lZBNjoMwDIX3nCLqKpmECkr5aWnmIlEWgYKaqgUEVIS5PGMziP14kefPSfwsd/P4aJtoWe5VTWpq2NUjkwzyQqpX1VCjAs2@4NC5kQU3vABVwNxxOOu2J47YhhgNP4a2H6s7HaqRDp83NUJpxphH4JWy4qnh3Y/taCEKFV41VyF/G0cLptGUlNhXgBPk08O@KlJimSgnZi3LY9d2lGHB1sTd1uGYae7EfcsAdb7tA6@4lY1yWs36Ju114tL6G@ebymdecnB2PAQbgWY8RPV39kOcqa/GT9@QafG63jYjralSqI6RfQuDXvMBc@Udsj0OwjvESXKOguh8WSk5Z3F0OmWX7S6NozRKkgQpzdIYAgRIww69f3liiyz4k5WwxfIL "Python 3 – Try It Online") Where d' represents the number of distinct values in the input. Edit: Saved 3 bytes thanks to @Mr.Xcoder.
] |
[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/165926/edit).
Closed 5 years ago.
[Improve this question](/posts/165926/edit)
Matrix challenges are popular. There's an issue of how to provide test cases. A common method is the *row-wise array-of-arrays* representation, such as:
```
[[1,2],[3,4],[5,6]] -> a 3 by 2 matrix
```
This is good with vertical space, but there's always the task of converting the test cases into something your language can use, and vice versa for producing test cases to this format.
So this is a [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") challenge and also a repository of conversion functions that people can use when trying or composing matrix challenges.
## Defining the format
A **row string of length *m*** is a comma-separated list of *m ≥ 1* numbers, enclosed in square brackets.
A **row-wise *n×m* array-of-arrays string** is a comma-separated list of *n ≥ 1* **row strings of length *m*** enclosed in square brackets with the following whitespace rules:
* has no whitespace before the first `[` or after the last `]`, except for an optional trailing newline.
* otherwise may contain spaces
## The challenge
Produce two\* programs/functions in your language:
1. one which takes a **rowwise *n×m* array-of-arrays string** as an input, and outputs the matrix (as implemented in the language.)
2. another one which takes an *n×m* matrix (as implemented in the language) as an input and outputs the **rowwise *n×m* array-of-arrays string**.
\*It is allowed for one program/function to perform both tasks and you can have helper code used by both conversion functions.
## Rules
* To be clear: the language must support matrices (or something equivalent like 2D arrays - the name is not important) because the output/input of the two tasks needs to be an actual matrix in the language.
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'").
* Fewest total number of bytes (from all functions and any helper code) in each language wins.
* If one program or function does both conversions, only count those bytes once.
* Standard rules apply/loopholes forbidden.
## Test strings
```
[[1]]
[ [ 1, 2 ], [ 3, 4 ] ]
[[1.2,3.4,5.6],[3,2,1], [10, 11, 12.1]]
```
Not really possible to provide test *matrices*.
### A non-golfed, possibly not bug-free worked example
I hope this doesn't violate the "don't answer your own question" guideline.
The R function I use [to convert from string to matrix](https://tio.run/##hZC9TsQwEIT7PMXI1VrsCeX4qaDkBRBUuQhxVvBZSpzIdoQR8OxhnQu0FCtr1ppvRhuWZZqM3Qfc7fA2e5Pc6ClrfFZALksb5yMpKIaSyVr2/iWM77F89p236RQpdHZ4TebURcoMK7LLUyB1ODSrSWvsUK9WM/arlf7z8q/zArXG5ZZaGPOwEmIKaXQ0@97FRKLi1LtE58LmS7Jl2r/i8rISnhAkL7hMBcQbl7dqjOOHaNzj6fH5QVffy1Cyzkci1TQ1Y8@4ahnNNeOGcdu2SlfD8gM)
The R function I use [to convert from matrix to string](https://tio.run/##NY69CsIwFIX3PMUl0w1cBys4iI6@QNGp7dDGWgJNGtIUI@Kzx4Tg9HF@4BwXo6uslROcd/DcjPRqMRgEfBjAtG4D8raljhMkZvy9horXJNh@9SNK5FlI9CgHZR5FhtTquBCiMOXLPPd2HeECnHLAvlHndd17pwLuT0eCiuBAMLzd8kq9W32/ClZ@ohbxBw)
*Here's the [Sandbox](https://codegolf.meta.stackexchange.com/a/16461/79980) and a [related question](https://codegolf.stackexchange.com/questions/129136/simplify-matrix-input).*
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 30 bytes
```
F=_OxZ}G=_Oo'[+Zm_'[+Z+']} +']
```
[Try it online!](https://tio.run/##y0osKPn/38023r8iqtYdSOWrR2tH5caDSG312FoFIPFfJVHBVsFNQyk62lDHKFYn2ljHBEia6pjFxippalpzuWskalr/BwA "Japt – Try It Online")
Function `F` converts a string into a matrix, and function `G` converts a matrix into a string.
] |
[Question]
[
You must write a program that evaluates a string that would be entered into an advanced calculator.
The program must accept input using stdin and output the correct answer. For languages that do no have functions to accept stdin, you may assume the functions `readLine` and `print` to handle these tasks.
**Requirements:**
* Does not use any kind of "eval" functions
* Can handle floating point and negative numbers
* Supports at least the +, -, \*, /, and ^ operators
* Supports brackets and parenthesis for overriding the normal order
* Can handle input containing one **or more** spaces between the operators and numbers
* Evaluates the input using the standard [order of operations](http://en.wikipedia.org/wiki/Order_of_operations)
## Test Cases
Input
```
10 - 3 + 2
```
Output
```
9
```
---
Input
```
8 + 6 / 3 - 7 + -5 / 2.5
```
Output
```
1
```
---
Input
```
4 + [ ( -3 + 5 ) * 3.5 ] ^ 2 - 12
```
Output
```
41
```
[Answer]
## C++, 640 583
```
string k="[]()+-*/^";stack<double> m;stack<char> n;
#define C(o,x,y) ('^'==o?x<y:x<=y)
#define Q(a) double a=m.top();m.pop();
#define R(o) {Q(b)Q(a)m.push(o=='+'?a+b:o=='-'?a-b:o=='*'?a*b:o=='/'?a/b:o=='^'?pow(a,b):0);n.pop();}
while(!cin.eof()){string s;getline(cin,s,' ');if(s.empty())continue;if('\n'==*--s.end())s.erase(--s.end());(s.size()==1&&s.npos!=k.find(s[0]))?({char c=s[0]=='['?'(':s[0]==']'?')':s[0];while(!n.empty()&&'('!= c&&C(c,k.find(c),k.find(n.top())))R(n.top());')'==c?n.pop():n.push(c);}):m.push(strtod(s.c_str(),0));}while(!n.empty())R(n.top());cout<<m.top()<<endl;
```
**Indented**
```
string k="[]()+-*/^";
stack<double> m;
stack<char> n;
#define C(o,x,y) ('^'==o?x<y:x<=y)
#define Q(a) double a=m.top();m.pop();
#define R(o) {Q(b)Q(a)m.push(o=='+'?a+b:o=='-'?a-b:o=='*'?a*b:o=='/'?a/b:o=='^'?pow(a,b):0);n.pop();}
while(!cin.eof())
{
string s;
getline(cin,s,' ');
if(s.empty())continue;
if('\n'==*--s.end())s.erase(--s.end());
(s.size()==1&&s.npos!=k.find(s[0]))?({
char c=s[0]=='['?'(':s[0]==']'?')':s[0];
while(!n.empty()&&'('!= c&&C(c,k.find(c),k.find(n.top())))
R(n.top());
')'==c?n.pop():n.push(c);
}):m.push(strtod(s.c_str(),0));
}
while(!n.empty())
R(n.top());
cout<<m.top()<<endl;
```
My first code golf, so looking forward to comments & criticism!
[Answer]
# PHP - ~~394~~ ~~354~~ 312 characters
```
<?=e(!$s=preg_split('#\s+#',`cat`,-1,1),$s);function e($P,&$s){$S='array_shift';if(($a=$S($s))=='('|$a=='['){$a=e(0,$s);$S($s);}while($s&&($p=strpos(' +-*/^',$o=$s[0]))&&$p>=$P){$b=e($p+($S($s)!='^'),$s);if($o=='+')$a+=$b;if($o=='-')$a-=$b;if($o=='*')$a*=$b;if($o=='/')$a/=$b;if($o=='^')$a=pow($a,$b);}return$a;}
```
Indented:
```
<?
preg_match_all('#\d+(\.\d+)?|\S#',`cat`,$m);
$s=$m[0];
function e($P) {
global $s;
if (strpos(" ([",$s[0])){
array_shift($s);
$a=e(0);
array_shift($s);
} else {
$a=array_shift($s);
if ($a=='-')$a.=array_shift($s);
}
while ($s && ($p=strpos(' +-*/^',$o=$s[0])) && $p >= $P) {
array_shift($s);
$b = e($p+($o!='^'));
switch($o){
case'+':$a+=$b;break;
case'-':$a-=$b;break;
case'*':$a*=$b;break;
case'/':$a/=$b;break;
case'^':$a=pow($a,$b);
}
}
return $a;
}
echo e(0);
```
[Answer]
# Postscript, 446
This uses the shunting yard algorithm.
```
[/*[/p
2/e{mul}>>/d[/p
2/e{div}>>/+[/p
1/e{add}>>/-[/p
1/e{sub}>>/o[/p
9/e{}>>/c[/p
-1/e{}>>/^[/p
3/e{exp}>>/p
0>>begin/s(%stdin)(r)file 999 string readline pop def
0 1 s length 1 sub{s exch[0 1 255{}for]dup[(\(o)([o)(\)c)(]c)(/d)]{{}forall
put dup}forall
pop
3 copy pop
get
get
put}for{s token not{exit}if
exch/s exch store{cvr}stopped{load
dup/p get
p
le{currentdict end
exch begin/e get exec}{begin}ifelse}if}loop{{e end}stopped{exit}if}loop
=
```
Un-golfed and commented:
```
% We associate the operators with their precedence /p and the executed commend /e
[
(*)[/p 2 /e{mul}>>
(d)[/p 2 /e{div}>> % This is division
(+)[/p 1 /e{add}>>
(-)[/p 1 /e{sub}>>
(o)[/p 9 /e{ }>> % This is open bracket
(c)[/p -1 /e{ }>> % This is close bracket
(^)[/p 3 /e{exp}>>
/p 0
>>begin
% Let's read the input string
/s(%stdin)(r)file 999 string readline pop def
% If we want to use the token operator, we have to replace (, [, ), ] and / to get meaningful results
% We use kind of an encoding array (familiar to PostScripters) to map those codes to o, c, and d.
0 1 s length 1 sub{ % index
s exch % string index
[0 1 255{}for] dup % string index translationArray translationArray
[(\(o) ([o) (\)c) (]c) (/d)] % string index translationArray translationArray reencodeArray
{ % string index translationArray translationArray translationString
{}forall % string index translationArray translationArray charCode newCharCode
put dup % string index translationArray translationArray
}forall % string index translationArray translationArray
pop % string index translationArray
3 copy pop % string index translationArray string index
get % string index translationArray charCode
get % string index translatedCharCode
put % -/-
}for
% Now we can actually start interpreting the string
% We use the stack for storing numbers we read and the dictionary stack for operators that are "waiting"
{ % number*
s token not{exit}if % number* string token
exch /s exch store % number* token
% We try to interpret the token as a number
{cvr}stopped{ % number* token
% If interpretation as number fails, we have an operator
load % number* opDict
% Compare operator precedence with last operator on dictstack
dup /p get % number* opDict opPrec
p % number* opDict opPrec prevOpPrec
le { % number* opDict
% If the last operator on the stack has at least the same precedence, execute it
currentdict end % number* opDict prevOpDict
exch begin % number* prevOpDict
/e get exec % number*
}{ % number* opDict
% If last operator doesn't have higher precedence, put the new operator on the dictstack as well
begin
}ifelse
}if
}loop
% If we're finished with interpreting the string, execute all operators that are left on the dictstack
{{e end}stopped{exit}if}loop
=
```
**TODO**: Right-associativity of exponentation
[Answer]
# [Python 2](https://docs.python.org/2/),~~339~~ 335 bytes
```
import re
x,s=input(),re.sub
def f(y):
y,r=s('- ','+ -',y).split(),['^','*','/','+','-']
for c in r:
while c in y:d=y.index(c)-1;a,b=map(float,[y[d],y[d+2]]);y=y[:d]+[((a,-a)[a<0]**b,a*b,a/b,a+b,a-b)[r.index(c)]]+y[d+3:]
return`y[0]`
w=lambda b:s("[([]+[\d+\-*/^ .]*[)\]]",lambda m:f(m.group()[1:]),s(' +',' ',b))
print f(w(w(x)))
```
[Try it online!](https://tio.run/nexus/python2#PZDJbsMgEIbvfoqRL2YMOFtzIfWTEKKAwQ2SN2FbCQ/ec4rVqoM@xKxi/rfvpzEsEFz2YnPth2ldCLLgqnk1mXUttCSiyCCyUM@k4FCwggIvWMRqnjq/VcvilqJlYrdlE7xQGbRjgAb8ACH1w/PhO/frR2HrWPnBuhdpkB8umpm61xNpu1EvTEZpFUsXPSqFl1hHKayikhDNuEapP/eqLA3TG7sETXCDMvzPVIpu/SeRvhHcsobhHuVe3bNn3eneWA1GzCSXRKa5V0uvvNzdoFKlxKtSOfsr6kVL@uorjOtEUB6EQpY0gG3DpINBzKbghyVp9EznhYjvd/4BFCQQ4Kf0OAMglACn6gwKbnAEDpsdjvn3MPJGNw/3Aw "Python 2 – TIO Nexus")
* -4 bytes by changing str(x) with backticks ``!
[Answer]
# Postscript, ~~1000~~ ~~695~~ ~~665~~ 494
Stole ideas from ThomasW. ~~Added feature: accepts strings with or without spaces around operators.~~*[feature removed]*
---
Using `ARGUMENTS` is shorter than `%stdin`, and easier to test, to boot!
---
Simplified the substitution to just replace brackets with parens.
```
575(1)10:36 PM:ps 0> gsnd -q -- calc2bg.ps '10 - 3 + 2'
9
576(1)10:37 PM:ps 0> gsnd -q -- calc2bg.ps '8 + 6 / 3 - 7 + -5 / 2.5'
1.0
577(1)10:37 PM:ps 0> gsnd -q -- calc2bg.ps '4 + [ ( -3 + 5 ) * 3.5 ] ^ 2 - 12'
41.0
```
Code:
```
/T[/^[/C{exp}/P 4/X{le}>>/*[/C{mul}/P 3/X{lt}>>/[/C{div}/P
3/X{lt}>>/+[/C{add}/P 2/X{lt}>>/-[/C{sub}/P
2/X{lt}>>>>def[/integertype{}/realtype{}/stringtype{V}/nametype{cvlit/N
exch store{P T N get dup/P get exch/X get exec{exit}if C end}loop T N get
begin}91 40 93 41>>begin/V{0 1 2 index length 1 sub{2 copy get
dup where{exch get}if 3 copy put pop pop}for[/N 0/R 0/P 0/C{}>>begin{token
not{exit}if exch/R exch store dup type exec R}loop{P 0 eq{end exit}if C
end}loop}def ARGUMENTS{V ==}forall
```
Ungolfed and commented:
```
%!
%Shunting-Yard Algorithm using dictstack for operators
%invoke with %gsnd -q -- calc2bg.ps [ 'expr1' ]*
%The operator table. C:code P:precedence X:test(implements associativity)
/T[
/^[/C{exp}/P 4/X{le}>>
/*[/C{mul}/P 3/X{lt}>>
/[/C{div}/P 3/X{lt}>>
/+[/C{add}/P 2/X{lt}>>
/-[/C{sub}/P 2/X{lt}>>
>>def
%The type-dispatch dictionary
%numbers: do nothing
%string: recurse
%name: process op
[%/integertype{}/realtype{} %now uses `where` below
/stringtype{V}/nametype{
pstack()=
cvlit/N exch store %stash cur-op
{
P %prec(tos)
T N get %prec(tos) cur-op-dict
dup/P get %prec(tos) cur-op-dict prec(cur-op)
exch/X get %prec(tos) prec(cur-op) test(cur-op)
exec{exit}if %exit if prec(tos) < || <= prec(cur-op)
/C load ==
C %pop-and-apply
end
pstack()=
} loop
T N get begin %push cur-op
}>>begin
%substitutions
[91 40 93 41>>begin %replace brackets with parens
/V {
%pre-process
0 1 2 index length 1 sub {
2 copy get
dup where { exch get } if
3 copy put pop pop
} for
dup ==
[/N 0/R 0/P 0/C{}>>begin %dummy base operator and storage
{ token not{exit}if exch /R exch store %extract token, stash Remainder
pstack(>)=
%dispatch type procedure
dup type dup where { pop exec }{ pop } ifelse
R }loop
pstack()=
{
P 0 eq{end exit}if %hit dummy op: exit
/C load ==
C end %pop and apply
} loop
} def
ARGUMENTS{V ==}forall %iterate through the command-line arguments
```
] |
[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/158044/edit).
Closed 5 years ago.
[Improve this question](/posts/158044/edit)
The [Peirce quincuncial projection](https://en.wikipedia.org/wiki/Peirce_quincuncial_projection) is pretty neat. It actually tessellates the whole plane:
[](https://commons.wikimedia.org/wiki/File:Peirce_quincuncial_projection_SW_20W_tiles.JPG)
Your job is to generate this map projection.
To simplify things, you will only need to generate the northern hemisphere.
Also, you will be given the stereographic projection of the northern hemisphere as input:
[](https://i.stack.imgur.com/NYxsC.jpg) (based on <https://commons.wikimedia.org/wiki/File:Stereographic_Projection_Polar_Extreme.jpg>).
Which means all that is left for you to do is to map this disk onto a square in an angle-preserving manner (as described [here](https://en.wikipedia.org/wiki/Peirce_quincuncial_projection#Formal_description)). (Note: You may assume that the disk touches all four sides of the input image.)
This is code-golf, so the shortest code wins!
]
|
[Question]
[
Given a string as input, output one or more variants of the string such that:
* No character is in it's original position
* No character is adjacent to a character that it was originally adjacent to
You can assume this will always be possible for the given string, and will only contain single case alphabetical characters (`[a-z]` or `[A-Z]` if you prefer)
Note that duplicates of the same character are not considered unique.
For example, given the input `programming`, the output cannot contain an `m` at the 7th **or** 8th character, and cannot contain a `g` at the 4th **or** 11th character (1 indexed)
## Example:
Take the string `abcdef`
The following would be a valid output: `daecfb`
However the following would be invalid: `fdbcae` as in this example `c` and `b` are still adjacent.
Adjacency also wraps, meaning you could not do `fdbeca` as `f` and `a` are still adjacent.
## Testcases:
Note these are not the **only** valid outputs for the given inputs
Written as `input -> output`:
```
helowi -> ioewhl
mayube -> euabmy
stephens -> nhseespt
aabcdeffghij -> dbfhjfigaeca
```
## Scoring:
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so fewest bytes **in each language** wins!
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~24~~ 23 bytes
```
ẋ2ṡ2Ṣ€
dzǤœ&¬ɓ³=Sȯ
ẊÇ¿
```
[Try it online!](https://tio.run/##y0rNyan8///hrm6jhzsXAvGiR01ruA63H9oMxEuOTlY7tObk5EObbYNPrOd6uKsLKLj/////xSWpBRmpecVf8/J1kxOTM1IB "Jelly – Try It Online")
Extremely long by virtue of my being awful at Jelly, but it finally works, at least... still in the process of golfing.
```
link that generates a list of sorted adjacent pairs:
ẋ2 duplicate argument ("abc" -> "abcabc")
ṡ2 slices of 2 (-> "ab","bc","ca","ab","bc")
Ṣ€ sort each
link that tests for invalid permutations:
Ç get sorted adjacent pairs of argument
³Ç¤ do the same for the original input
œ& set intersection, then...
¬ ...inverse; i.e. do they have no elements in common
ɓ ȯ logical OR the result of that with...
³= elementwise equality with original input, and...
S ...sum; i.e. are some characters in the same position
main link:
Ẋ shuffle the input list
¿ while
Ç the result of the previous link is truthy
```
[Answer]
# [Python 2](https://docs.python.org/2/), 185 bytes
```
from itertools import*
x=input()
g=lambda m:set(zip(m*2,(m*2)[1:]))
for l in permutations(x):
if not((g(l)|g(l[::-1]))&(g(x)|g(x[::-1]))or any(a==b for a,b in zip(x,l))):print`l`[2::5]
```
[Try it online!](https://tio.run/##NY29CsMgFEZ3n@JOjbekQwJdhDxJCESpSQX/MDdgSt/d6tDlDAe@88WL3sGPpWwpODCkE4VgDzAuhkR3lifj40kc2T5Z6dRLghOHJv4xkbv72DfgPIgFkW0hgQXjIerkTpJkgj94RsHAbOADcb5zi9@KWYjHUDe3anIz@W9qQ/qLy2lS0IKyVy3Z/nJvEVHEZDytdp1HIZ5LKZ2T16l09wM "Python 2 – Try It Online")
Prints all valid strings
[Answer]
# PHP>=7.1, 147 Bytes
```
for($a=$argn,$r="^$a[-1].*$a[0]$",$k=0;$v=$a[$k];)$r.="|^.{{$k}}$v|$v".($l=$a[$k++-1])."|$l$v";for(;preg_match("#$r#",$s=str_shuffle($a)););echo$s;
```
[PHP Sandbox Online](http://sandbox.onlinephpfunctions.com/code/ff9639358c96755feecb1e5016fbf58b726a67a6)
# PHP>=7.1, 184 Bytes
Use the levenshtein distance instead of a Regex way
```
for($a=$argn;$v=$a[$k];$r[]=$l.$v)$r[]=$v.($l=$a[$k++-1]);for(;!$t&&$s=str_shuffle($a);)for($t=1,$i=0;$v=$s[$i];$t*=$v!=$a[$i++])foreach($r as$x)$t*=levenshtein($x,$s[$i-1].$v);echo$s;
```
[PHP Sandbox Online](http://sandbox.onlinephpfunctions.com/code/82c1d3d19dd32cbf4eaef6073b13adc428be5285)
# [PHP](https://php.net/), 217 bytes
Version under 7.1
```
for($l=strlen($a=$argn),$r=$a[$k=0].$a[$l-1]."|".$a[$l-1]."$a[0]|^{$a[$l-1]}.*$a[0]$";$v=$a[$k];!$k?:$r.="|$v".$a[$k-1],++$k<$l?$r.="|$v".$a[$k]:0)$r.="|^.{{$k}}$v";for(;preg_match("#$r#",$s=str_shuffle($a)););echo$s;
```
[Try it online!](https://tio.run/##XY9NboMwEIX3vUWHt8ANscg2jsVBGidCyMSVXWOZNFkAx86amqBKVXbfvB/pTTBhPlTBhDfU8eIlGe26@xeJue1iDif7a3Ta56jlM8AKxESfsLJUfAG33SlOI/07EpVqPA1/ysQ/nhJI4La2lXiHrfaIXNKI29q2KVtsNrAHuOrFUvuSrdKJDwPsNCVLLCNFiPpy/q6vjckpQ8yoQL/sPvfmp22dTuMZE0zoxnToxZwtQEd/9Ijp0Yfvtk3dGP0L "PHP – Try It Online")
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 21 bytes
```
p.jP;?z≠ᵐ&j¬{s₂p~s}P∧
```
[Try it online!](https://tio.run/##ATYAyf9icmFjaHlsb2cy//9wLmpQOz964omg4bWQJmrCrHtz4oKCcH5zfVDiiKf//yJhc2RmZ2gi/1o "Brachylog – Try It Online")
## Explanation
I really would have wanted for `p.;?z≠ᵐ&j¬{s₂p~s~j}` to work for 2 bytes less, but it seems `~j` is not smart enough...
```
p.jP;?z≠ᵐ&j¬{s₂p~s}P∧ Input is a string, say ? = "asdfgha"
p Take a permutation of ?, say "sfagadh".
. It is the output.
j Concatenate it to itself: "sfagadhsfagadh"
P Call that string P.
;? Pair P with the input: ["sfagadhsfagadh","asdfgha"]
z Zip, repeating elements of the longer string:
[["s","a"],["f","s"],["a","d"],...,["a","g"],["d","h"],["h","a"]]
≠ᵐ Each pair must have different elements.
& Start new predicate
j Concatenate ? to itself: "asdfghaasdfgha"
¬{ } The following cannot be satisfied:
s₂ Take a substring of length 2
p and permute it.
~s It is a substring of
P P.
∧ Do not unify P with the output.
```
[Answer]
# PHP 7.1, ~~136~~ 131 bytes
inspired by [Jörg´s solution](https://codegolf.stackexchange.com/a/125350/55735):
```
for($a=$argn;$c=$a[$k];)$r.="|$c".($d=$a[$k-1])."|$d$c|^.{".+$k++."}$c";while(preg_match("#$a$r#",($s=str_shuffle($a)).$s));echo$s;
```
Run as pipe with `-r` or [test it online](http://sandbox.onlinephpfunctions.com/code/88d76bcb156a2ddeb88effca91b04f2958a04eae). (Make sure that PHP version 7.1 or above is selected)
Requires PHP 7.1; add 14 bytes for older PHP: Replace `$k-1` with `($k?:strlen($a))-1`;
(two more bytes for PHP<5.3: `$k?$k-1:strlen($a)-1`)
**breakdown**
```
# A: loop through input to collect sub-expressions
for($a=$argn;$c=$a[$k];)
$r.="|$c".($d=$a[$k-1]) # 1. pair of characters
."|$d$c" # 2. reversed pair
."|^.{".+$k++."}$c"; # 3. $c is at k-th position
# B: shuffle input until regex does not match the result
while(preg_match("#$a$r#",($s=str_shuffle($a)).$s)); # (input as dummy sub-expression)
# C: print result
echo$s;
```
[Answer]
# PHP 7.1, ~~187 185 172 178~~ 143 bytes
```
do for($r=str_shuffle($s=$argn),$p=$i=0;$c=$s[$i];$p+=($c==$z)+preg_match("#$a|$b#",$s.$s))$b=strrev($a=$r[$i-1].$z=$r[$i++]);while($p);echo$r;
```
Run as pipe with `-r` or [test it online](http://sandbox.onlinephpfunctions.com/code/a136a8d3393176a2361271a3126b9eefadf9959e). (Make sure that PHP version 7.1.0 or above is selected!)
**breakdown**
```
do
for($r=str_shuffle($s=$argn), # 2. shuffle input
$p=$i=0;$c=$s[$i]; # 3. loop through input
$p+=($c==$z) # 2. set $p if char is at old position
+preg_match("#$a|$b#",$s.$s) # or if adjacency occurs in input
)
$b=strrev($a=$r[$i-1].$z=$r[$i++]); # 1. concat current with previous character
while($p); # 1. loop until $p is falsy
echo$r; # 4. print
```
[Answer]
# Ruby, ~~110~~ ~~97~~ 102 bytes
```
->s{x=s.chars
t=s*2
x.shuffle!while s.size.times.any?{|i|a,b=(x*2)[i,2];a==s[i]||t[a+b]||t[b+a]}
x*''}
```
[Try it online!](https://tio.run/##JcvPDoIgHADgu09BXixUpvR/jXoQxgEcDDaz5k8XJj52Z9rq9J2@flRTNCyWV5g9A9JY2UMyMMA08QTsaEyrVy/rWo2AgHtrMri7BiK76TYHF2Sh2NpjuuGuoOIiGQPuRAgDl7n6qXIplsTjLFtiXf07mtETGZ5WNd3u9ofj6ZwKtMRP9ygb2Vj9BQ "Ruby – Try It Online")
[Answer]
# JavaScript 6, 116 Bytes
```
f=x=>(h=[...x].sort(_=>Math.random(z=0)-.5)).some(y=>y==x[z]||(x+x).match(y+(q=h[++z]||h[0])+'|'+q+y))?f(x):h.join``
```
```
f=x=>(h=[...x].sort(_=>Math.random(z=0)-.5)).some(y=>y==x[z]||(x+x).match(y+(q=h[++z]||h[0])+'|'+q+y))?f(x):h.join``
console.log (f('abcdef'));
```
[Answer]
# [Stax](https://github.com/tomtheisen/stax), ~~23~~ 21 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
å╘┤‼¬½P¥ë└w↕⌐î◘E{╟u!Ö
```
[Run and debug online!](https://staxlang.xyz/#p=86d4b413aaab509d89c07712a98c08457bc7752199&i=helowi%0Amayube%0Astephens%0Aaabcdeffghij&a=1&m=2)
Thanks for @recursive for saving 2 bytes.
Takes a very long time to run. A more reasonable/feasible version is (just 2 bytes longer)
```
Ç≡╨áiS║çdèû.#-Gî☺└╨◙σφ+
```
[Run and debug online!](https://staxlang.xyz/#p=80f0d0a06953ba87648a962e232d478c01c0d00ae5ed2b&i=helowi%0Amayube%0Astephens%0Aaabcdeffghij&a=1&m=2)
## Explanation
Uses the unpacked version to explain.
```
w|Nc_:=nGyG|*{E-!f+}ch+2B
w Loop anything before `}` while
|N Next permutation (starting from the input)
c_:= Index where the current array has the same element as the input (*)
}ch+2B Define a block that finds all contiguous pairs in current string, including the pair `[last element, first element]`
nG Apply the defined block to current string
yG Do the same for the input
|* Outer product, contains pairs (which themselves are pairs) constructed from the last two array.
{ f Only keep pairs
E-! whose two elements have the same set of characters
+ Prepend the array at step (*).
This is used as the condition for the while loop
```
] |
[Question]
[
# Can these rectangles fill a rectangular space?
Given a bunch of rectangles, you are asked whether or not they can be arranged to fill a rectangular space.
## Specs
Given a bunch of arbitrary `m x n` rectangles; `0 <= m, n <= 1000`, determine whether or not it is possible to arrange them so that they cover exactly a rectangular area without any holes or overlaps. The rectangles cannot be rotated, and each rectangle may only be placed once.
## Input
The input for this is very flexible, as long as the input gives some sort of list of 2-space dimensions. For example, both of the following are valid:
### Separated by Space, Return
```
1 2
1 5
4 5
3 6
```
### List of Dimensions
`[[1, 2], [1, 5], [4, 5], [3, 6]]`
## Output
Any sort of true/false values like true/false, 0/1, T/F, True/False, etc. If you are going to use an output method that's not very obvious, please specify in your answer.
## Examples
### Test Case 1
Input:
```
1 1
1 5
2 6
```
Output:
`true` (or something similar)
How to arrange it:
```
XYYYYY
ZZZZZZ
ZZZZZZ
```
### Test Case 2
Input:
```
1 1
2 2
```
Output:
`false` (or something similar)
Explanation: It becomes obvious that you cannot arrange two squares of different sizes and get their edges to line up.
### Test Case 3
Input:
```
1 1
1 2
1 2
2 1
2 1
```
Output:
`true` (or something similar)
How to arrange it:
```
AAB
DEB
DCC
```
As @ETHProductions pointed out, for all of the other test cases, you can keep combining rectangles with a common edge length until you have only one rectangle, so this test case is just to break any code that uses this idea.
### Test Case 4
Input:
```
3 2
4 1
2 1
4 1
2 1
5 2
3 2
1 4
3 2
2 1
2 1
1 1
5 1
```
Output:
`true` (or something similar)
How to arrange it:
```
AAABBBBEE
AAACCDDDD
FFFFFGGGH
FFFFFGGGH
IIIJJKKLH
IIIMMMMMH
```
**Note**: You do not need to state how to arrange it, you only need to determine whether not it can be arranged.
This is code golf, so the shortest answer in bytes wins! I will accept the shortest answer as of January 14th, but feel free to submit answers later than that since I can still give upvotes! :)
Happy golfing!
~ A.L.
P.S. If you know what tag should be applied to this problem, please add it, I have absolutely no idea what to put as a tag other than code-golf.
**EDIT**: Your program should be able to process up to 25 rectangles, in at most 10 seconds on a decent computer (I'll be quite flexible on this rule).
**EDIT**: I've extended the submission acceptance deadline to the last day of the year, but I doubt I'll get an answer by then...
**EDIT**: I've extended the submission acceptance deadline by 2 weeks, so if no more answers come in by then, the current C answer will be accepted! :)
[Answer]
# Haskell, 226 bytes
```
((y,z):l)&(w,x)|x*y<1=(w+y,x+z):l
(q:l)&p=p:q:l
(p@(u,v):r@(y,z):l)%q@(w,x)=[((y-w,z):l)&q&(u,v-x)|w<=y,x<=v]++[p:m|m<-(r:l)%q]
_%_=[]
g m(p:n)l=any(g[]$m++n)(l%p)||g(p:m)n l
g[]_[_,_,_]=0<1
g _[]_=0<0
($[(0,9^9),(9^9,0)]).g[]
```
[Try it on Ideone](https://ideone.com/hou73w)
### How it works
This recursively searches for all partial tilings whose shape is a [Young diagram](https://en.wikipedia.org/wiki/Young_diagram), adding one rectangle at a time, and checks whether any of the final results are rectangles.
To see that any tiling of a rectangle can be built this way: in any tiling of a nonempty Young diagram, let R be the set of rectangles in the tiling whose southwest corner does not touch any other rectangle. Since each concave vertex of the Young diagram is edge-adjacent (not merely corner-adjacent) to at most one rectangle in R, and the number of these concave vertices is one less than the number of rectangles in R, there must be at least one rectangle in R that is edge-adjacent to none of these concave vertices. Removing it yields another Young diagram, so we can proceed by induction.
[Answer]
## C, 1135 ~~1158~~ ~~1231~~ ~~1598~~ bytes
Well, it's past the stated deadline, but seeing as how there are no answers yet, here's one (a bit long) in C.
**Returns:**
* 0 (zero) on failure (don't fit)
* Full fitting matrix on success
---
### Update:
Original code could get stuck on some matrices, taking much longer than the allowed 10s. Current revision should complete all matrices in under 1s. This is accomplished by 1) Sorting the input rectangles and 2) skipping repeated sizes when fitting.
### Golfed:
```
#define R r[i]
#define Z return
#define _(B,D,E) for(int B=E;B<D;B++)
struct{int x,y,u,p;}r[25],*S;int A,M,N,U,V,X,Y;char *P;T(x,y,w,h){_(I,x+w,x)_(J,y+h,y)if(I/U|J/V|P[J*U+I])Z 0;Z 1;}L(x,y,w,h,c){_(I,x+w,x)_(J,y+h,y)P[J*U+I]=c;}F(){int x=0,y;while(++x<A)if(!P[x])break;if(x/A){_(i,V,0)printf("%*.*s\n",U,U,P+i*U);exit(0);}y=x/U;x-=y*U;_(i,N,0)if(!R.u&T(x,y,R.x,R.y))R.u=1,L(x,y,R.x,R.y,'A'+i),F(),R.u=0,L(x,y,R.x,R.y,0);}O(i,y){if(!R.u){if(!T(0,y,R.x,R.y))Z;R.u=1;R.p=0;L(0,y,R.x,R.y,'A'+i);y+=R.y;}if(y-V||F())_(j,N,0)if(j-i&!r[j].u){O(j,y);while(r[j].x-r[j+1].x|r[j].y-r[j+1].y)j++;}R.u=0;L(R.p,(y-=R.y),R.x,R.y,0);}Q(i,x){if(!R.u){if(R.x>U-x)Z;R.u=1;R.p=x;L(x,0,R.x,R.y,'A'+i);x+=R.x;}if(x-U||O(i,1))_(j,N,0)if(j-i&!r[j].u)Q(j,x);L(x-=R.x,0,R.x,R.y,0);R.u=0;}C(int*a,int*b){Z*a-*b?*a-*b:a[1]-b[1];}main(){_(i,25,0)if(++N&scanf("%d%d\n",&R.x,&R.y)-2)break;_(i,N,0){A+=R.x*R.y;if(R.x>X)X=R.x;if(R.y>Y)Y=R.y;}_(i,A+1,1)if(!(A%i)){if(i<Y|A/i<X)continue;M++;S=realloc(S,M*16);S[M-1].y=i;S[M-1].x=A/i;}qsort(S,M,16,C);P=calloc(A+1,1);_(j,M,0){U=S[j].x;V=S[j].y;_(i,N,0)R.u=1,L(0,0,R.x,R.y,'A'+i),Q(i,R.x),R.u=0;}printf("0\n");exit(1);}
```
### UnGolfed:
```
#define R r[i]
#define Z return
#define _(B,D,E) for(int B=E;B<D;B++)
struct {
int x,y,u,p;
} r[25],*S;
int A,M,N,U,V,X,Y;
char *P;
test_space(x,y,w,h) {
_(I,x+w,x)
_(J,y+h,y)
if ( I >= U |
J >= V |
P[J*U+I]) Z 0;
Z 1;
}
place_rect(x,y,w,h,c){
_(I,x+w,x)
_(J,y+h,y)P[J*U+I] = c;
}
fill_rest() {
int x=0,y;
while(++x<A) if (!P[x])break;
if (x>=A) {
_(i,V,0) printf("%*.*s\n", U,U, P+i*U);
exit(0);
}
y = x / U; x -= y*U;
_(i,N,0)
if (!R.u & test_space(x, y, R.x, R.y))
R.u = 1,
place_rect(x, y, R.x, R.y, 'A'+i),
fill_rest(),
R.u = 0,
place_rect(x, y, R.x, R.y, 0);
}
fill_y(i,y) {
if (!R.u) {
if (!test_space(0, y, R.x, R.y)) Z;
R.u = 1;
R.p = 0;
place_rect(0, y, R.x, R.y, 'A'+i);
y += R.y;
}
if (y == V) fill_rest();
else _(j,N,0)
if (j!=i && !r[j].u){ fill_y(j, y);
while (r[j].x^r[j+1].x||r[j].y^r[j+1].y)j++;
}
R.u = 0;
place_rect(R.p, (y -= R.y), R.x, R.y, 0);
}
fill_x(i,x) {
if (!R.u) {
if (R.x > U - x) Z;
R.u = 1;
R.p = x;
place_rect(x, 0, R.x, R.y, 'A'+i);
x += R.x;
}
if (x == U) fill_y(i, 1);
else
_(j,N,0)
if (j!=i && !r[j].u) fill_x(j, x);
place_rect((x -= R.x), 0, R.x, R.y, 0);
R.u = 0;
}
C(int*a,int*b) {
Z *a^*b?*a-*b:a[1]-b[1];
}
main() {
_(i,25,0)
if (++N&&scanf("%d %d\n", &R.x, &R.y)!=2) break;
_(i,N,0){
A+=R.x*R.y;
if(R.x>X)X=R.x;
if(R.y>Y)Y=R.y;
}
_(i,A+1,1)
if (!(A%i)) {
if (i < Y | A/i < X) continue;
M++;
S = realloc(S,M*16);
S[M-1].y=i;
S[M-1].x=A/i;
}
qsort(S, M, 16,C);
P = calloc(A + 1,1);
_(j,M,0){
U = S[j].x; V = S[j].y;
_(i,N,0)
R.u = 1,
place_rect(0, 0, R.x, R.y, 'A'+i),
fill_x(i, R.x),
R.u = 0;
}
printf("0\n");
exit(1);
}
```
**Explanation:**
We have 6 functions: `main`, `O`, `Q`, `F`, `L` and `T`. `T` **t**ests to see if there is space for the rectangle at a given spot. `L` fil**l**s a rectangle into the output buffer or, alternately removes one by overwriting it. `O` and `Q` build up the left and top walls, respectively and `F` **f**ills the remainder of the rectangle by iterative search.
Although the basic search is iterative, we eliminate the vast majority of possible search vectors, first by building up the allowed combinations of width and height for the master rectangle and then eliminating impossible configurations. Additional speed could be gained in larger rectangles by determining bottom and right walls prior to filling the center but it is not required for decent speed when limiting to 25 interior rectangles.
] |
[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/118630/edit).
Closed 6 years ago.
[Improve this question](/posts/118630/edit)
## Challenge
Supplied an image, you must determine if the subject of the image is a bird or a plane.
If the image is a bird, your program must output
```
bird
```
and if the image is a plane, your program must output
```
plane
```
Your program must produce no other output and the testing program will be case sensitive.
## Further information
All images will be the objects in flight.
The images of planes and birds will be against blue backgrounds (in some there may be light cloud in patches).
All birds will be pictured gliding from underneath, with their wings spread open. They will not always be the same species.
All planes will be commercial jetliners, pictured from the side. Their liveries may differ and the models will not be the same.
You may not use any external libraries, functions or online resources which perform image recognition.
The images will not be revealed to the competitors.
## Examples
The following examples will ***not*** be used in the 30 test images.
### Birds
## Planes
## Winning
Given 60 images of birds and planes, the program which identifies the most of then correctly wins.
In case of a tie, first post wins.
### Note:
Thank you to Beta Decay for writing this challenge! Beta allowed me to take it and post. [Sandbox](https://codegolf.meta.stackexchange.com/questions/2140/sandbox-for-proposed-challenges/5648#5648)
]
|
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
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).
Closed 6 years ago.
[Improve this question](/posts/118146/edit)
The problem is I need to skip or delete all the lines between the two keywords in a file and the keyword pair will appear many times in the file.The file looks something like this
```
.
.
..........
..........
Hello world
..........
..........
welcome
.
.
.
..........
..........
Hello world
..........
..........
welcome
.
.
.
.........
.........
Hello world
..........
..........
welcome
.
.
.
..........
..........
```
Here the contents between Hello world and welcome are to be deleted (including those keywords). Please help me out with this.
]
|
[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/114798/edit).
Closed 6 years ago.
[Improve this question](/posts/114798/edit)
Very few, if any, programs or applications have utilised the proposed spec for [WOM](https://en.m.wikipedia.org/wiki/Write-only_memory) which was initially thought up in the early 1970s as a polar opposite to ROM, so your task is to take a dataset of n Integers and simulate storing it to a WOM schema as a proof of concept.
Your array must contain 1 or more integers. Smallest solution wins.
]
|
[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/112915/edit).
Closed 6 years ago.
[Improve this question](/posts/112915/edit)
In honor of national pi day, create a program that, when given an integer, `n`, as input, will create a circular "pie" constructed of these smaller pies:
[](https://i.stack.imgur.com/UM0Ir.jpg)
Your program should output the image in a closed polygonal shape, and the number of outputted images should be equal to the value of the nth digit of pi.
Below are some possible answers. Please consider the `*`s as copies of the given image. You can treat the below as test cases.
```
N = 1 (first digit of pi: 3)
*
* *
n= 4 (4th digit of pi: 1)
*
n=33 (33rd digit of pi: 0)
```
This is code golf, so the shortest solution (in bytes) wins!
[Digits of pi](http://www.joyofpi.com/pi.html)
]
|
[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/109602/edit).
Closed 7 years ago.
[Improve this question](/posts/109602/edit)
# The challenge
You are given an integer `n`, and you have to use these operations to make it 1.
1. Divide it by 3.
2. Divide by 2.
3. Subtract 1.
# Examples:
```
Input Output
1 0 (Its already 1, guys)
5 3 (3->2->2 or 3->3->1)
10 3 (3->1->1)
255 10(3->3->3->1->1->2->2->3->1->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/109476/edit).
Closed 7 years ago.
[Improve this question](/posts/109476/edit)
(I am not sure that this is the best place to put this question, but I will give it a shot. Forgive me if it is improper. This is just a fun project with which I am tinkering and I am looking for advice on how best to implement it; but it is also something of a 'challenge' (not implying that it is hard!), so I thought that it might fit here)
Here is the basics of the problem.
I have a list of words (strings); basically, it is a partial dictionary in a language but nothing but the words are included. I want to check whether I can make any of the following exchanges in their spelling exactly once and yet still generate a word which is already present in the list:
• (b f)
• (p v)
• (c z)
• (j s)
By "exchange exactly once", I mean that only one occurrence of one letter in a word gets switched to its partner.
If such an exchange produces a word in the list, then I want to be notified about it (by printing the pair of words and moving to the next line). I want to check the whole word list for any pair of words such that if exactly one occurrence of one of these letters in them is changed to the partner letter, then the new word is also in the list (being the other word).
To be clear, these are not all of the consonants which are present in the word list; there are also vowels. These letters are just pairs which I want to exchange.
So, "bats" would become "fats" and vice-versa, and perhaps both of those words are in the list; if so, then the check would tell me so. On the other hand, "baba" would generate "faba" or "bafa" (and vice-versa), but not "fafa" (because that would be exchanging two occurrences of one letter); likewise, "jazz" would generate "sazz", "jacz", and "jazc", but nothing else; none of the generated words in this example would be in an English word list.
There are additional constraints on the list though, which are helpful:
• Every word in the list is four letters long (so I do not need to check string lengths).
• No occurrence of a letter can be adjacent to another occurrence of the same letter. So, "jazz" does not occur in the list because there is the substring "zz", which adjacently repeats a letter.
• "b", "j", "v", and "z" may be mutually adjacent, and "p", "c", "f", and "s" may be mutually adjacent, but none of those first four characters can be adjacent to any of the second four characters.
• All words in the list are of the form 'CVCC' or the form 'CCVC', where 'C' represents a consonant and 'V' represents a vowel. This means that the list is partitioned into two classes of words.
The word list is approximately one thousand five hundred (1500) words long.
---
I want to do this efficiently. A really simply effort, which I will describe, seems rather poor.
This effort would be this:
0) Look at the file of words. Sort the word list alphabetically. (It comes this way)
1) Run through the word list and discard any of the words which lack any of these letters: "b", "p", "v", "f", "z", "s", "j", "c". Counting multiplicities (words which have multiple occurrences of these letters get counted as many times as there are occurrences), the list has N words; in other terms, these letters occur N times in the word list.
2) Sort the word list into two sublists based on the form of the words (put them into two different files and close the original one, then open each of these new files in turn?). One will have $N\_1$ words and the other will have $N\_2$ words, counting multiplicities (where $N\_1 + N\_2 = N$). It turns out that $N\_1, N\_2 > 300$.
3) Now, in each list, run through and compare each occurrence of a letter against the corresponding letter in each subsequent word. So, the first word will be checked against the second, third, fourth, ..., nth words - but really, the ith letter in the first word will be checked against the ith letter in the jth word, running over all $i \in [1,4], j>1$; then the second word will be compared against the third, fourth, fifth, ..., nth words; ...; all the way down to the penultimate word, which will end the loop. Comparison will just at most three checks (see if the first letters form such a pair, see if the second consonants form such a pair, see if the third consonants form such a pair; if the ith consonant of the word being checked against all of the subsequent words is not one of these letters, then we can ignore the ith consonant in all of the checks and move on to the (i+1)st consonant).
(I should say that words may differ in only their vowel without notifying me, such as "fats" and "fits". This is okay and I do not want to be notified about these pairs.)
4) If a word differs by only one occurrence of a letter from another word and the differing letters are one of the pairs which I mentioned, then print both words (separated by a space) and move to a new line.
Done.
Now, this is really slow. I think that it takes at least $(N1-1)! + (N2-1)!$ comparisons. I can speed it up a bit (for example: since the sorting is alphabetic, I know that "b"-initial words could/should be checked against only "f"-initial words for their first consonant (I do not need to run through the whole list - just the "f"-initial section of it) - but this is only for the first letters, and it makes the code somewhat less elegant).
Is there any better way to do this?
(If we are framing it as a challenge: Produce the method which needs to do the least number of comparisons. Ties will be broken in favor of code 'elegance' and brevity (in bytes).)
---
I am most familiar with C++ and want to do it in that language if possible. But I will take any advice or code which works.
]
|
[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/109387/edit).
Closed 7 years ago.
[Improve this question](/posts/109387/edit)
Feb. 6 was a real weekday. Because it lies in the 6th week of the year.
So a real weekday is a day with a a day number that equals the week number.
But not all country have the same counting of weeks. in Germany a week starts with Monday and ends on Saturday in the US they start on Sunday.
Write a program that checks a given date (the format your program likes the best) and a weekstart ('S' or 'M') whether it is a real weekday.
Too simplify things a bit we assume January 1st is always a real weekday because it is in the first week. In Germany it is the last day of week 52)
Some examples of real weekday for a start on Monday:
```
2017-01-01
2017-02-07
2017-04-17
```
Some examples of real weekday for a start on Sunday:
```
2017-01-01
2017-02-06
2017-04-16
```
Example:
```
2017-04-16 S Output: YES
20170416M Output: 0
```
How you enter the Date does not matter, as long as it is human readable. The start day can be given by M or S or 1 or 0.
the Output is a printed boolean Yes, not or Y,N or 0,1
Shortest code wins!
Its my first question I put on this forum, so I'd be happy to hear some comments.
[Answer]
# MATLAB, 53 bytes
```
d=datetime(input(''));week(d-(input('')=='M'))==d.Day
```
This answer accepts the first input as a string `'2017-02-06'` and the second input as a string (either `'S'` or `'M'`).
[](https://i.stack.imgur.com/bw3IC.gif)
It constructs a `datetime` object from the first input and saves it in `d`. We then compute the week number (but first we subtract 1 day from the date if the second input is an `'M'` since `week` uses Sundays by default) and then we compare this week number to the day of the `datetime` object to yield a boolean.
] |
[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/109142/edit).
Closed 7 years ago.
[Improve this question](/posts/109142/edit)
# Simple Mancala Game
Create a mancala game using as few bytes as possible.
## The game
Mancala is a family of games where a player has a control over a set amount of pots filled with stones/seeds. The particular version which you should implement has a board with 14 pots, of which two are designated as scoring pots. At the start of the game the scoring pots are empty and each of the other pots contains 4 stones. On each player's turn they select one non-empty non-scoring pot, remove the stones from it, and starting with the next pot counter-clockwise they place one stone per pot, moving counterclockwise, until they have placed them all.
Unlike some other variants, there is no way to get a second turn. Once the stones from one pot have been redistributed, the play passes to the other play.
The game ends when all the stones are in the scoring pots, so that there is no valid move remaining.
## The challenge
Implement a simple program to allow two players to play against each other at a shared computer. No AI is required.
For the purposes of input, the pots are labelled as shown:
```
(R1H1)[R1P6][R1P5][R1P4][R1P3][R1P2][R1P1]
[R2P1][R2P2][R2P3][R2P4][R2P5][R2P6](R2H1)
```
The scoring pots are `(R1H1)` and `(R2H1)`.
The input will be a list of pots separated by a semicolon: e.g. `R2P3;R2P1`. These represent the moves in order from left to right. You may assume that each move is valid.
The output will be the number of stones in each pot after the input moves have been performed. The output need not use brackets in the same way as the diagram above or the examples below, but the pots must be distinguishable and the scoring pots should also be clearly distinguished from regular ones.
## Worked example
The initial board position is
```
(0)[4][4][4][4][4][4]
[4][4][4][4][4][4](0)
```
Given input `R2P3` the output should be
```
(0)[4][4][4][4][4][4]
[4][4][0][5][5][5](1)
```
placing the four stones from `R2P3` in the first four pots working counter-clockwise from `R2P3`.
Given input `R2P3;R2P1` the output should be
```
(0)[4][4][4][4][4][4]
[0][5][1][6][6][5](1)
```
]
|
[Question]
[
So... uh... this is a bit embarrassing. But we don't have a plain "Hello, World!" challenge yet (despite having 35 variants tagged with [hello-world](/questions/tagged/hello-world "show questions tagged 'hello-world'"), and counting). While this is not the most interesting code golf in the common languages, finding the shortest solution in certain esolangs can be a serious challenge. For instance, to my knowledge it is not known whether the shortest possible Brainfuck solution has been found yet.
Furthermore, while all of ~~[Wikipedia](https://en.wikipedia.org/wiki/List_of_Hello_world_program_examples)~~ (the Wikipedia entry [has been deleted](https://en.wikipedia.org/wiki/Wikipedia:Articles_for_deletion/List_of_Hello_world_program_examples) but there is a [copy at archive.org](https://web.archive.org/web/20150411170140/https://en.wikipedia.org/wiki/List_of_Hello_world_program_examples)
), [esolangs](https://esolangs.org/wiki/Hello_world_program_in_esoteric_languages) and [Rosetta Code](https://rosettacode.org/wiki/Hello_world/Text) have lists of "Hello, World!" programs, none of these are interested in having the shortest for each language (there is also [this GitHub repository](https://github.com/leachim6/hello-world)). If we want to be a significant site in the code golf community, I think we should try and create the ultimate catalogue of shortest "Hello, World!" programs (similar to how our [basic quine challenge](https://codegolf.stackexchange.com/q/69/8478) contains some of the shortest known quines in various languages). So let's do this!
## The Rules
* Each submission must be a full program.
* The program must take no input, and print `Hello, World!` to STDOUT (this exact byte stream, including capitalization and punctuation) plus an optional trailing newline, and nothing else.
* The program must not write anything to STDERR.
* If anyone wants to abuse this by creating a language where the empty program prints `Hello, World!`, then congrats, they just paved the way for a very boring answer.
Note that there must be an interpreter so the submission can be tested. It is allowed (and even encouraged) to write this interpreter yourself for a previously unimplemented language.
* Submissions are scored in *bytes*, in an appropriate (pre-existing) encoding, usually (but not necessarily) UTF-8. Some languages, like [Folders](https://esolangs.org/wiki/Folders), are a bit tricky to score - if in doubt, please ask on [Meta](https://meta.codegolf.stackexchange.com/).
* This is not about finding *the* language with the shortest "Hello, World!" program. This is about finding the shortest "Hello, World!" program in every language. Therefore, I will not mark any answer as "accepted".
* If your language of choice is a trivial variant of another (potentially more popular) language which already has an answer (think BASIC or SQL dialects, Unix shells or trivial Brainfuck-derivatives like Alphuck), consider adding a note to the existing answer that the same or a very similar solution is also the shortest in the other language.
As a side note, please *don't* downvote boring (but valid) answers in languages where there is not much to golf - these are still useful to this question as it tries to compile a catalogue as complete as possible. However, *do* primarily upvote answers in languages where the authors actually had to put effort into golfing the code.
For inspiration, check [the Hello World Collection](https://helloworldcollection.github.io/).
## The Catalogue
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:
```
## [><>](https://esolangs.org/wiki/Fish), 121 bytes
```
```
/* Configuration */
var QUESTION_ID = 55422; // Obtain this from the url
// It will be like https://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 8478; // This should be the user ID of the challenge author.
/* App */
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, 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.toLowerCase() > b.lang_raw.toLowerCase()) return 1;
if (a.lang_raw.toLowerCase() < b.lang_raw.toLowerCase()) 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);
}
}
```
```
body {
text-align: left !important;
display: block !important;
}
#answer-list {
padding: 10px;
width: 290px;
float: left;
}
#language-list {
padding: 10px;
width: 500px;
float: left;
}
table thead {
font-weight: bold;
}
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="https://cdn.sstatic.net/Sites/codegolf/all.css?v=ffb5d0584c5f">
<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>
```
[Answer]
# Stuck, 0 bytes
Well, can't get shorter than that...
An empty program will output `Hello, World!` in [Stuck](http://esolangs.org/wiki/Stuck).
[Answer]
# [PHP](https://php.net), 13 bytes
```
Hello, World!
```
Yes. It works.
[Try it online!](https://tio.run/##K8go@P/fIzUnJ19HITy/KCdF8f9/AA "PHP – Try It Online")
[Answer]
# Brainfuck, 78 bytes
~~***Open-ended bounty:** If anyone can improve this score, I will pass the bounty (+500) on to them.*~~
[@KSab](https://codegolf.stackexchange.com/users/15858/ksab) has found a [~~76~~ 72 byte solution](https://codegolf.stackexchange.com/a/163590/4098)!
```
--<-<<+[+[<+>--->->->-<<<]>]<<--.<++++++.<<-..<<.<+.>>.>>.<<<.+++.>>.>>-.<<<+.
```
[Try it online!](https://tio.run/nexus/brainfuck#HYqBCQBACAIHEp1AXCR@/zH6SkU4tEnTRqGMkMzZ9suzSRknDWhqWMlmPtrhiItQ9wc)
The first 28 bytes `--<-<<+[+[<+>--->->->-<<<]>]` initialize the tape with the following recurrence relation (mod 256):
\$f\_n=171(-f\_{n-1}-f\_{n-2}-f\_{n-3}+1)\$, with \$f\_0=57, f\_1=123,f\_2=167\$
The factor of \$171\$ arises because \$3^{-1}=171 \pmod{256}\$. When the current value is translated one cell back (via `<+>---`) subtracting \$3\$ each time effectively multiplies the value by \$171\$.
At \$n=220\$ the value to be translated is zero, and the iteration stops. The ten bytes preceding the stop point are the following:
\$[130, 7, 43, 111, 32, 109, 87, 95, 74, 0]\$
This contains all of the components necessary to produce `Hello, World!`, in hunt-and-peck fashion, with minor adjustments.
I've also found an alternative 78 byte solution:
```
-[++[<++>->+++>+++<<]---->+]<<<<.<<<<-.<..<<+.<<<<.>>.>>>-.<.+++.>>.>-.<<<<<+.
```
[Try it online!](https://tio.run/nexus/brainfuck#HUqBCQAwCDpI7ALxkdj/ZzRLTDQdNtACTCOakx4D4ymoFZYqBhfKDr2/rC/xivQzHw)
I consider this one to be better than the first for several reasons: it uses less cells left of home, it modifies less cells in total, and terminates more quickly.
---
### More Detail
Recurrence relations have surprisingly terse representations in Brainfuck. The general layout is the following:
```
{...s3}<{s2}<{s1}[[<+>->{c1}>{c2}>{c3...}<<<]>{k}]
```
which represents:
\$f\_n=c\_1f\_{n-1}+c\_2f\_{n-2}+c\_3f\_{n-3}+\cdots+k\$
with
\$f\_0=s\_1, f\_1=s\_2+c\_1f\_0+k,f\_2=s\_3+c\_2f\_0+c\_1f\_1+k,\text{etc.}\$
Additionally, the `<+>` may be changed to multiply the range by a constant without affecting the stop point, and a term may be added before the `>{k}` to shift the range by a constant, again without affecting the stop point.
---
### Other Examples
**Fibonacci Sequence**
```
+[[<+>->+>+<<]>]
```
***N*-gonal Numbers**
*Triangular Numbers*
```
+[[<+>->++>-<<]>+]
```
Defined as \$f\_n=2f\_{n-1}-f\_{n-2}+1\$, with \$f\_0=0,f\_1=1\$.
*Square Numbers*
```
+[[<+>->++>-<<]>++]
```
*Pentagonal Numbers*
```
+[[<+>->++>-<<]>+++]
```
etc.
---
### BF Crunch
I've published the code I used to find some of this solutions on [github](https://github.com/primo-ppcg/BF-Crunch). Requires .NET 4.0 or higher.
```
Usage: bfcrunch [--options] text [limit]
Arguments
------------------------------------------------------------
text The text to produce.
limit The maximum BF program length to search for. If zero, the length of the
shortest program found so far will be used (-r). Default = 0
Options
------------------------------------------------------------
-i, --max-init=# The maximum length of the initialization segment. If excluded, the
program will run indefinitely.
-I, --min-init=# The minimum length of the initialization segment. Default = 14
-t, --max-tape=# The maximum tape size to consider. Programs that utilize more tape than
this will be ignored. Default = 1250
-T, --min-tape=# The minimum tape size to consider. Programs that utilize less tape than
this will be ignored. Default = 1
-r, --rolling-limit
If set, the limit will be adjusted whenever a shorter program is found.
-?, --help Display this help text.
```
Output is given in three lines:
1. Total length of the program found, and the initialization segment.
2. Path taken, starting with the current tape pointer. Each node corresponds to one character of output, represented as (pointer, cost).
3. Utilized tape segment.
For example, the final result for `bfcrunch "hello world" 70 -r -i23` is:
```
64: ++++[[<+>->+++++>+<<]>]
49, (45, 5), (44, 3), (45, 6), (45, 1), (45, 4), (42, 4), (43, 5), (45, 3), (45, 4), (46, 2), (44, 4)
32, 116, 100, 104, 108, 132, 0, 0, 132, 0
```
This corresponds to the full program:
```
++++[[<+>->+++++>+<<]>]<<<<.<+.>++++..+++.<<<.>+++.>>.+++.>.<<-.
```
---
### Other Records
**Hello, World!**
*Wrapping, ~~**78 bytes**:~~*
*[Surpassed by @KSab (72)](https://codegolf.stackexchange.com/a/163590/4098)*
```
--<-<<+[+[<+>--->->->-<<<]>]<<--.<++++++.<<-..<<.<+.>>.>>.<<<.+++.>>.>>-.<<<+.
```
or
```
-[++[<++>->+++>+++<<]---->+]<<<<.<<<<-.<..<<+.<<<<.>>.>>>-.<.+++.>>.>-.<<<<<+.
```
*Non-wrapping, ~~**80 bytes** (previously [92 bytes (mitchs)](http://codegolf.stackexchange.com/a/55506)):~~*
*[Surpassed by @KSab (76)](https://codegolf.stackexchange.com/a/163590/4098)*
```
-[[<]->+>>>>+>+>+>+>+>+]>>>>+.>>>++.<++..<.<<--.<+.>>>>>>--.<<<.+++.>.>-.<<<<<+.
```
**Hello, world!**
*Wrapping, ~~**80 bytes**:~~*
*[Surpassed by @KSab (77)](https://codegolf.stackexchange.com/a/163590/4098)*
```
++<-[[<+>->+>--->-<<<]>+++]>+.<<<<<<<++.>>>..>.<<--.<<<--.>>+.>>>.+++.<.<<<-.<+.
```
*Non-wrapping, **81 bytes** (previously [92 bytes (hirose)](http://golf.shinh.org/reveal.rb?Helloworldless+Hello+world/hirose_1313505002&bf)):*
```
+>---->->+++>++>->+[++++++++[>++++++++>>+++++<<<-]<]>>.>++>.>..+>>.+>-->--[>-.<<]
```
**hello, world!**
*Wrapping, ~~**74 bytes**:~~*
*[Surpassed by @KSab (70)](https://codegolf.stackexchange.com/a/163590/4098)*
```
-<++[[<+>->->+++>+<<<]->]<<.---.<..<<.<<<---.<<<<-.>>-.>>>>>.+++.>>.>-.<<.
```
*Non-wrapping, **84 bytes**:*
```
---->+++>++>->->++[+++++++[>+++++[>++>>+<<<-]<-]++<]>>>>.---.>---..+>->.+>-->+>[-.<]
```
---
### [Esolangs](http://esolangs.org/wiki/Brainfuck) Version
**Hello World!\n**
*Wrapping, **76 bytes**:*
```
+[++[<+++>->+++<]>+++++++]<<<--.<.<--..<<---.<+++.<+.>>.>+.>.>-.<<<<+.[<]>+.
```
This uses one cell left of home, and thus would be considered 77.
*Non-wrapping, **83 bytes**:*
```
->+>>>+>>---[++++++++++[>++++++>+++>+<<<-]-<+]>+>+.>.->--..>->-.>[>.<<]>[+>]<<.>++.
```
[Rdebath approved](https://esolangs.org/wiki/Talk:Brainfuck#Shortest_known_.22hello_world.22_program.). profilebf output:
```
Hello World!
Program size 83
Final tape contents:
: 0 0 73 101 109 115 112 88 33 10 0
^
Tape pointer maximum 10
Hard wrapping would occur for unsigned cells.
Counts: +: 720 -: 79 >: 221 <: 212
Counts: [: 9 ]: 84 .: 13 ,: 0
Total: 1338
```
---
### [inversed.ru](http://inversed.ru/InvMem.htm#InvMem_7) (Peter Karpov)
**Hello World!**
*Wrapping, **70 bytes** (previously 781):*
```
+[++[<+++>->+++<]>+++++++]<<<--.<.<--..<<---.<+++.<+.>>.>+.>.>-.<<<<+.
```
*Non-wrapping, **77 bytes** (previously 89?):*
```
->+>>>+>>-[++++++[>+++++++++>+++++>+<<<-]<+]>>.>--.->++..>>+.>-[>.<<]>[>]<<+.
```
The author claims that the shortest hand-coded "Hello World!" is 89 bytes, but provides no reference. I hereby claim the record for this, too.
**hello world!**
*Wrapping, **65 bytes** (previously 66 bytes):*
```
+++[>--[>]----[----<]>---]>>.---.->..>++>-----.<<<<--.+>>>>>-[.<]
```
This is actually hand-coded as well (the best I could find by crunching is [68 bytes](https://tio.run/nexus/brainfuck#HYiBCQBACAIHkpxAXCTaf4w@X1C8W1y6BZdzYUjj0YUCvyQzMUHan32mruDuAw)). The first cell is initialized to 259 (3), and decremented by 7 each iteration, looping 37 times. The next cell is decremented by 6, resulting in 256 − 6·37 = 34. The rest of the cells are decremented by 4 each time, adding one cell each iteration, with each new cell inialized to 252 (-4). The result is the following:
```
[ 3, 0, 0, 0, 0, 0, 0, ...]
[252, 250, 248, 0, 0, 0, 0, ...]
[245, 244, 244, 248, 0, 0, 0, ...]
[238, 238, 240, 244, 248, 0, 0, ...]
[231, 232, 236, 240, 244, 248, 0, ...]
[224, 226, 232, 236, 240, 244, 248, ...]
...
[ 35, 64, 124, 128, 132, 136, 140, ...]
[ 28, 58, 120, 124, 128, 132, 136, ...]
[ 21, 52, 116, 120, 124, 128, 132, ...]
[ 14, 46, 112, 116, 120, 124, 128, ...]
[ 7, 40, 108, 112, 116, 120, 124, ...]
[ 0, 34, 104, 108, 112, 116, 120, ...]
```
1 The solution given (79 bytes) can be trivially reduced by one:
```
-[>>+>+[++>-<<]-<+<+]>---.<<<<++.<<----..+++.>------.<<++.>.+++.------.>>-.<+.
```
[Answer]
# [ArnoldC](http://lhartikk.github.io/ArnoldC/), 71 bytes
```
IT'S SHOWTIME
TALK TO THE HAND "Hello, World!"
YOU HAVE BEEN TERMINATED
```
Just for lols...
[Try it online!](https://tio.run/##DcmxCoAgEADQ3a@4XFr6CcMDpVTIK2mMbDsS/H@4euu7@tu43iKexgzZpUI@oCKzLkAJyCE4Ey1o9zC3CUrrXAetzrT/cSDMiBEIt@CjIbQiHw "ArnoldC – Try It Online")
[Answer]
# [Seed](https://esolangs.org/wiki/Seed), ~~6016~~ ~~4234~~ 4203 bytes
```
20 854872453003476740699221564322673731945828554947586276010721089172712854441839676581917455319274850944955030258951339804246125714958815519550291630078076933441706558540342671975808828643360922071900333028778314875248417953197990571991784126564752005357199892690656368640420204822142316716413192024742766282266114842280731756458212469988291309261528542889299297601723286769284159107438930448971911102280330101196758384815655479640836157495863547199726234352265518586460633795171196315255736880028338460236768181141732764911402112878175632130129852788301009582463631290071329795384336617491655825493435803011947670180368458659271192428341035912236946048939139042310380278430049252171822721598175984923434205610723412240162418996808671543770639111617709604242882388664919702606792443015941265168129550718541372361144081848761690730764968771245566074501485020726368378675085908872608679630368472956274468410052703615106090238423979678950131481176272880569100533049143775921798055136871254424261001442543122666701145111965968366507060931708140304772342855064834334129143038575569044150428480231956133612367393837580345180691911525531699573096952433882387811884727975431823620782822755161559988205401134640722220804177812794328129589949692446031008866917615922944976151073653201316255518389496411696741029209242119521978920200314572718584995265523235225587228975886710511855501710470163649632761488899317729943053884132314641377747687975638119132094777769497069556255954031537245957811105217875011509899497752696062748928963281605780942517262774976217663461063680912331030221981433051827519906741285738915397005702326447635845195923640649166530310494885569783989508000344280715868581532826832242144647203531393142251025361866506821695860883605004105862208004440476654027574832078603305884731766236740069411566854496824754558761536201352147934963241039597221404341132342297870517293237489233057335406510464277610336142382379135365550299895416613763920950687921780736585299310706573253951966294045814905727514141733220565108490291792987304210662448111170752411153136765318541264632854767660676223663544921028492602135525959428999005153729028491208277493747933069008199074925710651071766675870081314909460661981433426167330215548196538791617762566403934129026219366764038390123622134753742930729751695349588862441999672547791630729398908283091638866715502470152431589429837867944760012419885615525232399584379209285060418518373512154801760060312646951597932345591416241634668119867158079946680321131213357200382937049485606706114467095019612014749723443159443363662563254359712162432143334612180576945072905749883870150120687696027984317320305291407322779803583395375616762530641605634303022155218169343410634115050596030685041633824154135240376022159918501703555881290333205131375705406831260759974112248490451605422031345264183102048614606636275942039438138959188478277971377232005036301145411215067576576667743288951344423152531417111852584846747428443123174595987315325304540564683047858415059703724263652136185848573853965992798725654430360647040362341567082462847275277303225817689141675391972818943419663764371222973269129542760661385278009266471167618553065823580448848795731295589715602705860758954890415040763604082216728159486423396295188510311881004469017351709060492844398219491990895826924575575549615118821417543037296628825303328056839433114519945243963946989899508355224823109677424196639930153649890175062456649384605721510239142861693109687536600667811037619175927995599388547421689316110236566026931360164495251160997857372500940728057700473763884480342708897319990346726967220426504612260565552531158509215849649565188655100774748485416791517853427613458459889062942881409801879085054494129489535044719193283409051007851153504224002807392992520076910314763705776345053922387355156981872691537772657428096384535960466923475731297217863371650154415835785630016335858514130863258775100537612371430357576913148500310344278511588325852376442503898849856566716198848377379400158332792027967216204970114516984638014129252882482309132898416484525230488700253065644547798869056136044415413099076332059572505138116227535024546891015836838323022822272664771489129085797354578016574544759934333471793
```
[Try it online!](https://tio.run/##JdfZdR05DATQVBwCSXDNZxyB8z@aWy3/WHpPTQK1Af3v79//fn5G@3PXvGfMVa3VPPvMtt8bo689a4x96lR/c91x15pvnnX3OLv1dkZv9/UzTvfdnLPfevvsdbtP51qeG2fe1d6cb61Wbaz7Vq96t80xdx/rdF/d29fq@ZPx@lbIue3sV@XM0/ZajlecYvpzf7uKUV3tptDmQ6WX0@85t7p21pjXoy8lnPeaa56afDa2vnzf2qrv0/vGfu7YtZ2prDbavPqfo7oL9@zpo415pr738N3e3S1zDGVWP04ET9eQ464WSl27r6Ayrgvg@QLZGaVwnQ2VrAfCWfdVm/M@tfTeW87USm@9w3LduhM4IJjnKe@Wc08g2@Uj9Z@xR81aqoLh9cXcbVdpvp8cUgpZ62jvNhCVE3cbpYzbrz76KX1Nt882OirPTUs1tNHHu2uce1NRc6sey4kD4qeXrkB8w8TGOO5QNagkBekjTURSrftlXyjtRRI@HYCp2VtBYSjmqQkIBbvXgnyr21w8iWG@sYZeAE9y66W8d33qFnStHSk6bIzZ@h5k@N4mEuStWYeAKtCq8LS3IzykjLp3p@t32gDYUZLLHP9ppANnRJCuXRTggnCOgI6QszvNnGrBbVMd7tfaG5@r9SieKkcUVUcZq931iNZHqQolHxrHBaw0p5@hC@cWdnsjawTRV8F3H5ZpPbLu/fh7xev55QlC0UF6BCu5@4K7FMRYM32CRj3Tbzgj21DR5@rRxVI53rSYC8lYb1zW5gmacXvbE0kVaHMLStbRJoKoF46QUCffbpZmZpqqV3oO9265kiSqjv546T0qxMDjTioMBaTWb5A4fK1Gn23Q3ZjMVThb6/NUEwC912SBM/xrAgSfSDpPTH1koR0b4XE3AmohmOmdISUSQedDlxNWjSC61aVKFvTcpBBgY2JwewQKJLp78E8mOHKuZB2LTa3Ebuwc4xG9om6iKaJr8IUe0vw8IU4ILojLkCgPAjbyFY5C7TOSwxM05xx@uUFjF2zYQS0YOUJDAwBFgAtfArGvSnCD9SY6YhLRByeJ@4FBF8KNuhPDQidF3L7F4XXqEBDCw5WQ8eze8KU@AmpcWTGhPOoMhy9dXZxInBaU6OMATgmqciAhjD0Vz/gzWc6eyIrDaKxCiOFxb/QjpF9ELY/oZCZFu2gArONQT5cj@COSNGRESQUIQRo7i9RudLtl7k4SYtooWJICCKZT1EGjwlxPgFK2/ivC2gnXFclVGo5kZ4Mq9vk3U4wrRP2aIZVeoseO5C5/62MxqaW9kxHRJFAPfWrT1mmB9Pn9wztXnZLTxov2t/nhyBav8DatH/y6YX2DL5BMYFGBwEJ7Ojzx9f00K4ijnNjVqWAQ8E8LTxWQm5lyIWh@kQ5BKeFaYs1UddC77AfW5qGZNJEnLaPSD4E4o7u@uMNklLKS3TvhuJPRmThSFwUJXzNE8awNCxQ@utB9FPm@P@hY@LQFC9AVkFky8jkJdNZIdScsZM6dfFnpIqMACr@qS4RJFTqUBGoWW1LjfWHOBxIcGV9ASXFSVeXJZxTWEkhIstSoaqJFdDBWNFPf0nGDg4rYXkKe8@0e4Q8Vijf08klihD5XNgDzQXYRq5bfb7i/iF7KglFQrSTW@IJBRhhf5wsTE8Hgga20ObW6bmRnz4PJquCNTaKKdkhP3H6TLI7cyYFvmNEBV/ugGc7A0psdJtFk6ajzGWyFrvbNKv9ncjzJbAjE5c5O9UqmQVCNjHm562KHudC5vkoMDOm9EjoriLTsHFx2g4Beo8wEi/TVYzYIUbEyJUhVdGcUCQKLHuhXKHQXCcyEj6bqN1lAZQXZWRdmgicu5GOTyffc2IKA5oybGRMiFmR50DZ3E7BuWVkflahukgeLG0/mhRiBLIVbkpw8shOaXSs18CvcQQ16nPRv6WPLSI9qTjRNWdazLuXwkciIniFVGZBZII3r@uZpTlc5HbPQJ@iTofTtunJofCtYxZc9o8EWrBTJczJDM5or@7JrODQRCCqHQspqkIGckRNkRG0SP5sF5JKDOSlBLA0M9Bc@aFnoBWLNkCzQsiHKNxPe/ja@eWvbkAa4Eh0mzic4Psk@ZETQtyekC7xpGHacI@Bf5mzW4Di0vtWwZdd1Tw/JmXuYswRm/xMyWZYy9r9lKkvuimiS0nhJ4HHat0xYpdRrv8LuTgkYsMrK0Cfi@IZ3MOb/nmwXJj1GIvE46304PgPhZaXj3uyq2QWysZy8uGT2e3qEhRV0yDrb/A3apJOl6obx@jYkRovVBT7HyQMBZ2Al8Mgo@@kLyeMXJLncMipmgsPxBu5MNr1v117ZWikMuPjO6vg9blSzoADYGd9Rdl6bsh@7CpeCZ0UhVlEP7LwboN0TIwcAy6uJGDMTCZrEowPc4yM7UtwrU825kwhDRV6gKAAJlczzK5yz8rACSeFgZ0fM1FifXAWORULtN@vRyzSRhTYmu3@0G@lFNZYAM2rl@B1Lmf@yAi8jgyFLpTTodGANbhkhiWvEewHDZN57pJ5FE5Xf2Zju33dZ6Nv3jvW9QuWl7WTx5SRNnXQoM5zp@yyT2KEvgyObdlYTa5PG4jJ448KpeQGwFo5MhU@WJwM270teXpCY1RbNish7aOIHCjdTtezurGnbX9/ufbLxnm8vXjH@@3b0lUXx22p@@xCaI6M7RrJxiWrY0MkKle7M0LCbMKNJ4sKE5sjQGFn9E8ote9@nSa2Zy7AMgOCg3WixZUt0LC5w8k0fYZaJ@mWuFJnfdEPey9tSfDZ/I7VlHO8vOLlUeQKLGHe278rEWzPZ8JXFHXpJbvOo15CYXvs3mYBZyWg/yGbZAzkgE7z1jRNT/tXPz/8 "Seed – Try It Online")
The resulting Befunge-98 program (based on [this](https://codegolf.stackexchange.com/a/55486/30688)) is
```
"9!dlroW ,olleH"ck,@
```
[Try it online!](https://tio.run/##S0pNK81LT9W1tNAtqAQz//9XslRMySnKD1fQyc/JSfVQSs7Wcfj/HwA "Befunge-98 (PyFunge) – Try It Online")
[Answer]
## [Mornington Crescent](https://github.com/padarom/esoterpret), ~~3614~~ 3568 bytes
*Thanks to NieDzejkob for saving 46 bytes by using shorter line names.*
```
Take Northern Line to Hendon Central
Take Northern Line to Bank
Take Circle Line to Bank
Take District Line to Gunnersbury
Take District Line to Victoria
Take Victoria Line to Seven Sisters
Take Victoria Line to Victoria
Take Circle Line to Victoria
Take Circle Line to Bank
Take Circle Line to Hammersmith
Take Circle Line to Cannon Street
Take Circle Line to Hammersmith
Take Circle Line to Cannon Street
Take Circle Line to Bank
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Gunnersbury
Take District Line to Paddington
Take District Line to Acton Town
Take Piccadilly Line to Holloway Road
Take Piccadilly Line to Acton Town
Take District Line to Acton Town
Take District Line to Gunnersbury
Take District Line to Hammersmith
Take Circle Line to Notting Hill Gate
Take District Line to Upminster
Take District Line to Notting Hill Gate
Take District Line to Upminster
Take District Line to Victoria
Take Victoria Line to Seven Sisters
Take Victoria Line to Victoria
Take Circle Line to Victoria
Take District Line to Upminster
Take District Line to Gunnersbury
Take District Line to Mile End
Take District Line to Hammersmith
Take Circle Line to Notting Hill Gate
Take District Line to Upminster
Take District Line to Upminster
Take District Line to Mile End
Take District Line to Paddington
Take Circle Line to Paddington
Take District Line to Acton Town
Take Piccadilly Line to Heathrow Terminals 1, 2, 3
Take Piccadilly Line to Holborn
Take Central Line to Holborn
Take Central Line to Mile End
Take District Line to Upminster
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Barking
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Gunnersbury
Take District Line to Barking
Take District Line to Gunnersbury
Take District Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Wood Lane
Take Circle Line to Victoria
Take Circle Line to Victoria
Take District Line to Gunnersbury
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Gunnersbury
Take District Line to Paddington
Take Circle Line to Paddington
Take District Line to Mile End
Take Central Line to Fairlop
Take Central Line to Mile End
Take District Line to Barking
Take District Line to Upminster
Take District Line to Upminster
Take District Line to Hammersmith
Take Circle Line to Notting Hill Gate
Take District Line to Upminster
Take District Line to Mile End
Take District Line to Gunnersbury
Take District Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Hammersmith
Take District Line to Mile End
Take District Line to Richmond
Take District Line to Mile End
Take District Line to Paddington
Take Circle Line to Paddington
Take District Line to Richmond
Take District Line to Bank
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Stepney Green
Take District Line to Hammersmith
Take District Line to Stepney Green
Take District Line to Upney
Take District Line to Notting Hill Gate
Take Circle Line to Notting Hill Gate
Take Circle Line to Notting Hill Gate
Take District Line to Upminster
Take District Line to Upney
Take District Line to Upminster
Take District Line to Bank
Take Circle Line to Bank
Take Northern Line to Charing Cross
Take Bakerloo Line to Charing Cross
Take Bakerloo Line to Paddington
Take Circle Line to Bank
Take Circle Line to Bank
Take Northern Line to Mornington Crescent
```
[Try it online!](https://tio.run/##xVdLbsJADN33FHMAumh7gpK2sACE@LRrk1jNiMRGzlDE6akRn4pAGJIS2CBFz3ie7Wd7JmUhS9@O6TEUzEIkt1qNYIqmx@JiFDIdS2gcmzZSxGQCNRFIHk4bNYGmGyiwEiZ4AnizmRMbuj3UmhOhZJO5LAssPvWDxcIG3n3t4SH@IJmh/kvdFNgcusiROwsWhtSGNNUDU@vik3gARJqwoRNEV5OHy8kdJXU8Sy2tU1aA/9@Dv7B9iKKN/AoMXrUwZEa82Br0bRhCZJNk@ceTk4QXsDQDhqjQKu/Ie1KFaHzl7LFzGq1pKzPTAocV83otP7dtqxrk07V62jtFd66HD/fQzDdBjuVVegTBxcILM0JRrpBk5qlhnhvm5VxbTXQ5bClthv5loCfc@udOE2SqGbvjXDvPoPxc9EgiB38xR6YDhOWXnadlK8zAG2yNsg1zKNC8fD/ASsKzSto@X/f/zpFbzTNPkHXL1y8hD8GBDeOUC@Gax7Hn9BpvbEOHM8Klael1kSr35yVexmuLcreTy7Ra24Yu5uvfJt4nzdEzKIhB1rwD4Wx7dWrqj84VLmXj0WIVat39i09P3r34fgE "Mornington Crescent – Try It Online")
This is most certainly suboptimal, but it's half the size of the solution on esolangs.
`Hello, World` is constructed via slicing the following station names and concatenating the results:
```
Hendon Central
▀▀
Holloway Road
▀▀▀
Heathrow Terminals 1, 2, 3
▀▀
Wood Lane
▀▀
Fairlop
▀▀
Richmond
▀
```
Finally, I'm computing the character code of `!` as `(2<<4)+1 == 33`. All these parts are concatenated in Paddington and finally printed in Mornington Crescent.
**Note:** The language doesn't specify whether it's possible to travel to same station twice in a row, but the interpreter does allow it, so I've made use of it.
[Answer]
# brainfuck, 72 bytes
```
+[-->-[>>+>-----<<]<--<---]>-.>>>+.>>..+++[.>]<<<<.+++.------.<<-.>>>>+.
```
[Try it online!](https://tio.run/##HYpBCoBADAMfVJoXhHyk7EEFQQQPgu@v2Z3DEMLs73Y953fc3VGZypJCOSEHba@hhPxbQEQUNGjmxmoT5Gocdf8)
And the original non-wrapping **76 byte** solution:
```
+[+[<<<+>>>>]+<-<-<<<+<++]<<.<++.<++..+++.<<++.<---.>>.>.+++.------.>-.>>--.
```
[Try it online!](https://tio.run/##HYhRCoBAEEIPJOMJZC6y7EcFQQR9BJ1/ckeRp@7vdj3nd9xVGBiSkNaEwvYSMCUaHWKVXhHBTGZf0WKuy6z6AQ "brainfuck – Try It Online")
### Other shortest known (to my knowledge) solutions I've found
**'Hello, world!' 77 bytes:**
```
+[+++<+<<->>>[+>]>+<<++]>>>>--.>.>>>..+++.>>++.<<<.>>--.<.+++.------.<<<-.<<.
```
[Try it online!](https://tio.run/##HUrJCYBAECsoTCoIaWTZhwqCCD4E6x9nJ4/c@7tdz/kddyYGAEEK2wOeLg/MSo6gWUrWp0yRJPag7qKx2kXM/AE)
**'hello, world!' 70 bytes:**
```
+[>>>->-[>->----<<<]>>]>.---.>+..+++.>>.<.>>---.<<<.+++.------.<-.>>+.
```
[Try it online!](https://tio.run/##HYpBCoAwEAMftGxeEPKR0oMWCiJ4EHz/mnYOQ0hyvsf1zG/cVdEkpbItGZJd6oIzFEBEQAKtVXnfVW5An/yq@gE)
---
These were found using a c++ program I wrote here: <https://github.com/ksabry/bfbrute>
Note: I originally wanted to clean up this code before I posted it to make it actually somewhat readable and usable, but since I haven't gotten around to it in over a year I figure I'll just post it as is. It makes heavy use of templates and compile time constants for any potential optimizations and it has a bunch of commented out code from my testing but no helpful comments so sorry but it's a bit horrible.
There is nothing terribly clever about the code, it's brute forcer at it's core, however it is quite optimized. The major optimization is that it first iterates through all programs without loops (no `[` or `]`) up to a specified length (16 currently) and caches an array of all the changes it will make on the data array. It will only store a single program per unique array of changes so for example only one of `>+<<->` and `<->>+<` will be stored. It then iterates through all possible programs which are composed of any program in this cache with any combination of loops between them. After executing each program it does a simple greedy hunt and peck for the characters and appends this to the end of the program.
After running this through the space of all programs I noticed that almost all the shortest programs (up to length ~19) were of the form `*[*[*]*]`. Restricting the search to programs of this form sped up the search considerably. The current record holder was found at length 27. This one was actually computed to be length 74, but I noticed a particular sequence `.>.>.>.` which was lucky enough to have a 0 in the data cell to it's right allowing it to be simplified to `[.>]<` bringing it down to 72.
I let it run for quite awhile and completed the search with the current parameters up to length 29, I suspect it will be difficult to beat the current one by simply going higher, I think the most promising approach would probably be increasing the search space in some intelligent way.
[Answer]
# [evil](http://esolangs.org/wiki/Evil), 70 bytes
```
aeeeaeeewueuueweeueeuewwaaaweaaewaeaawueweeeaeeewaaawueeueweeaweeeueuw
```
[Try it online!](https://tio.run/##JYs5CsBADAPfOsUUgbSOnu9dOyAJdPk9bzfqMGWV0RokQATD1Wzz71jrJkx6j@k@ "evil – Try It Online")
It uses the following four commands:
```
a - increment the register
u - decrement the register
e - interweave the register's bits (01234567 -> 20416375)
w - write the value of the register as an ASCII character
```
[Answer]
# Piet, 90 codels
[](https://i.stack.imgur.com/TZNsF.png)
This is a 30 by 3 image. Alternatively, at codel size 10:
[](https://i.stack.imgur.com/TnaHd.png)
The uses a 3-high layout so that I only need to pointer once. If this is still golfable I could probably shave at most another column, since there's a push-pop no-op in there.
Edit: [@primo's 84 codel solution](https://codegolf.stackexchange.com/a/67601/21487).
[Answer]
# [Haystack](https://github.com/kade-robertson/haystack), 17 Bytes
Haystack is a 2D programming language that executes until it finds the needle in the haystack `|`, all while performing stack-based operations. All programs start from the top left corner, and can use the directional characters `><^v` to move around the program. Direction is inherited, so you do not need to keep using `>` to go right, direction will only change when it hits a different directional character.
By default, the interpreter reads from the top left going right, so we can just put "Hello, World!" onto the stack, use `o` to print it, then place the needle to finish executing.
```
"Hello, World!"o|
```
[Try it online!](https://tio.run/##y0isLC5JTM7@/1/JIzUnJ19HITy/KCdFUSm/5v9/AA "Haystack – Try It Online")
Bonus: A more exciting version:
```
v >;+o|
v "
v !
v d
v l
v r
>>"Hello, ">>>v
W v
" v
^<<<<<<<
```
[Answer]
# [Help, WarDoq!](http://esolangs.org/wiki/Help,_WarDoq%21), 1 byte
```
H
```
Not only does [Help, WarDoq!](http://esolangs.org/wiki/Help,_WarDoq%21) have a built-in for most common spellings of the phrase, it even satisfies our usual definition of programming language.
Try it in the [official online interpreter](http://cjam.aditsu.net/#code=l%3AQ%7B%22HhEeLlOoWwRrDd%2C!AaPpQq%22Q%7C%5B%22Hh%22%22ello%22a%5B'%2CL%5DSa%22Ww%22%22orld%22a%5B'!L%5D%5D%3Am*%3A%60%5B%7Briri%2B%7D%7Briri%5E%7D%7Brimp%7D%7Brizmp%7DQ%60Q%7B%5C%2B%7D*%60L%5D%2Ber%3A~N*%7D%3AH~&input=H) (code goes in *Input*).
[Answer]
# [MarioLANG](https://esolangs.org/wiki/MarioLANG), ~~259~~ ~~249~~ ~~242~~ ~~240~~ 235 bytes
```
+>+>)+)+)+++)++++((((-[!)>->.
+"+"===================#+".")
+++!((+++++++++)++++++)<.---+
++=#===================")---.
++((.-(.)).+++..+++++++.<---
!+======================---
=#>++++++++++++++.).+++.-!>!
=======================#=#
```
[Try it online!](https://tio.run/##bY6xDsIwDET3fEXiLLFOvi9o/CNMnRAStBL/LwUXyoDIsywP5zv7sT5v@33drmPA4Yqj8G60wC5F3ZwJAun/VAhFU2yX1vBFz7HQzBBqrxOvaKiRHIdojaoMD3lmcAk15YI@5RB7dfzAT4QVLynnuTFeqWO8AA "MarioLANG – Try It Online")
This has been tested [in the Ruby implementation](https://github.com/mynery/mariolang.rb).
[After obfuscating "Hello, World!"](https://codegolf.stackexchange.com/a/54928/8478) in MarioLANG I looked into golfing it a bit. The above is the shortest I have found so far.
As before I started from a Brainfuck solution which sets four cells to the nearest multiple of 10 to the characters `He,` and space [and converted it to MarioLANG](https://codegolf.stackexchange.com/q/55380/8478). You can then shorten the code a bit by making use of the auxiliary floor in the loop which almost halves the width of the loop. Note that the bottom is only executed one time less than the top, so you don't get exact multiples of the initial counter in all 4 cells any more.
Finally, I wanted to make use of the wasted space in front of the loop, so I added a bunch of elevators to make use of the vertical space there. And then I realised that I could fold the code *after* the loop (see previous revision) below the loop to make use of some more vertical space, which saved five more bytes.
This is likely still far from perfect, but it's a decent improvement over the naive solution, I think.
## Metagolf
Time for some automation...
I have started setting up a solver in Mathematica to find an optimal solution. It currently assumes that the structure of the code is fixed: counter set to 12, 4 cells for printing, with the fixed assignment to `He,<space>` and the same order of those cells. What it varies is the number of `+`s in the loop as well as the necessary corrections afterwards:
```
n = 12;
Minimize[
{
3(*lines*)+
12(*initialiser base*)+
Ceiling[(n - 6)/2] 3(*additional initialiser*)+
8(*loop ends*)+
18(*cell moves*)+
26(*printing*)+
43*2(*steps between letters in one cell*)+
-2(*edge golf*)+
4 Max[4 + a + d + g + j + 2 Sign[Sign@g + Sign@j] + 2 Sign@j + 2,
4 + b + e + h + k + 2 Sign[Sign@h + Sign@k] + 2 Sign@k] +
2 (Abs@c + Abs@f + Abs@i + Abs@l),
a >= 0 && d >= 0 && g >= 0 && j >= 0 &&
b >= 0 && e >= 0 && h >= 0 && k >= 0 &&
n*a + (n - 1) b + c == 72 &&
n*d + (n - 1) e + f == 101 &&
n*g + (n - 1) h + i == 44 &&
n*j + (n - 1) k + l == 32
},
{a, b, c, d, e, f, g, h, i, j, k, l},
Integers
]
```
It turns out, that for an initial counter of 12 my handcrafted solution is already optimal. However, using 11 instead saves two bytes. I tried all counter values from 6 to 20 (inclusive) with the following results:
```
6: {277,{a->7,b->6,c->0,d->16,e->1,f->0,g->0,h->9,i->-1,j->0,k->6,l->2}}
7: {266,{a->6,b->5,c->0,d->11,e->4,f->0,g->2,h->5,i->0,j->0,k->5,l->2}}
8: {258,{a->2,b->8,c->0,d->3,e->11,f->0,g->5,h->0,i->4,j->4,k->0,l->0}}
9: {253,{a->8,b->0,c->0,d->5,e->7,f->0,g->2,h->3,i->2,j->0,k->4,l->0}}
10: {251,{a->0,b->8,c->0,d->3,e->8,f->-1,g->4,h->0,i->4,j->3,k->0,l->2}}
11: {240,{a->1,b->6,c->1,d->1,e->9,f->0,g->4,h->0,i->0,j->3,k->0,l->-1}}
12: {242,{a->6,b->0,c->0,d->6,e->3,f->-4,g->0,h->4,i->0,j->0,k->3,l->-1}}
13: {257,{a->1,b->5,c->-1,d->6,e->2,f->-1,g->3,h->0,i->5,j->0,k->3,l->-4}}
14: {257,{a->1,b->4,c->6,d->0,e->8,f->-3,g->3,h->0,i->2,j->2,k->0,l->4}}
15: {242,{a->1,b->4,c->1,d->3,e->4,f->0,g->1,h->2,i->1,j->2,k->0,l->2}}
16: {252,{a->0,b->5,c->-3,d->4,e->2,f->7,g->0,h->3,i->-1,j->2,k->0,l->0}}
17: {245,{a->4,b->0,c->4,d->5,e->1,f->0,g->0,h->3,i->-4,j->0,k->2,l->0}}
18: {253,{a->4,b->0,c->0,d->1,e->5,f->-2,g->2,h->0,i->8,j->0,k->2,l->-2}}
19: {264,{a->0,b->4,c->0,d->5,e->0,f->6,g->2,h->0,i->6,j->0,k->2,l->-4}}
20: {262,{a->0,b->4,c->-4,d->5,e->0,f->1,g->2,h->0,i->4,j->0,k->2,l->-6}}
```
**Note:** This solver assumes that the linear code after the loop is all on the top line, and the above code is that solution folded up. There might be a shorter overall solution by making the solver aware of the folding, because now I get 3 more `+`s in the first part for free, and the next 4 instructions would cost only 1 byte instead of 2.
[Answer]
# [Dark](https://esolangs.org/wiki/Dark), 106 bytes
```
+h hell
h$twist sign s
s$scrawl " Hello, World!
s$read
h$twist stalker o
o$stalk
o$personal
o$echo
h$empty
```
I'll just let some quotes from the language specification speak for the brilliance of this esolang:
>
> Dark is a language based on manipulating entire worlds and dimensions to achieve goals and to build the best torturous reality possible.
>
>
>
>
> Whenever a syntax error occurs, the program's sanity decreases by 1. [...] If the program's sanity reaches zero, the interpreter goes insane.
>
>
>
>
> Corruption flips a single bit in the variable when it occurs.
>
>
>
>
> When the master dies, all servant variables attached to that master also die. This is useful for grouping and mass killing variables.
>
>
>
>
> Forces a variable to kill itself, freeing it (remember though that it will leave decay).
>
>
>
>
> Sets a variable to a random value. Uses the Global Chaos Generator.
>
>
>
>
> If a stalker is not initialized, any attempts to perform IO will result in depressing error messages to be written to the console.
>
>
>
[Answer]
# [Homespring](https://esolangs.org/wiki/Homespring), 58 bytes
```
Universe net hatchery Hello,. World! powers a b snowmelt
```
[Try it online!](https://tio.run/##DcrBCYAwDAXQVb53cQ4XEM9Vgy2kSUmDxemj7/yyVurNitwRm5SHrBOEHDn5mclerMSs84Jdja8JaDr@hIQDXXRUYkfEBw "Homespring – Try It Online")
The trailing space is significant.
Let me tell you a story. There was once a power plant which powered a nearby salmon hatchery. The salmon hatchery hatched a young homeless salmon which embarked on a journey upriver to find a spring. It did find such a spring, with the poetic name "Hello, World!", where it matured and spawned a new young salmon. Both fish now swam downstream, in search of the wide ocean. But just short of the mouth of the river, there was a net in the river - the mature fish was caught and only the young one managed to slip through and reached the ocean and the rest of the universe. In the meantime, the hatchery had hatched more salmon which had travelled upstream as well and spawned and so on and so on.
However, vast amounts of melting snow had been travelling down a different arm of the river. And just after our first young salmon from the springs of "Hello, World!" has reached the ocean, the snowmelt hit the universe and... uh... destroyed it. And they lived happily ever after... or I guess they didn't.
Those were actually the semantics of the above program. Homespring is weird.
[Answer]
# [Chef](https://esolangs.org/wiki/Chef), 465 bytes
```
H.
Ingredients.
72 l h
101 l e
108 l l
111 l o
44 l C
32 l S
87 l w
114 l r
100 l d
33 l X
Method.
Put X into mixing bowl.Put d into mixing bowl.Put l into mixing bowl.Put r into mixing bowl.Put o into mixing bowl.Put w into mixing bowl.Put S into mixing bowl.Put C into mixing bowl.Put o into mixing bowl.Put l into mixing bowl.Put l into mixing bowl.Put e into mixing bowl.Put h into mixing bowl.Pour contents of the mixing bowl into the baking dish.
Serves 1.
```
[Try it online!](https://tio.run/##ldGxDoMgEIDh/Z7inoBINdHdpR2aNHFxrXIWUgoJYu3b0yNdOrA4/eHjYLlZ05LSWQBc3COQMuTiKqA9oUUNspJc4nZcC1Lms4em4fRQ56kBupaz82XWwMMVV0Fdc0aAK0XtlYDbFnFE46LHl/kY98DJ71ZkVmW2ZQ5l9mXeyzyUuT/0tz3EVGZdYL8FnL2LeRvoF4ya/gd@LzJO92dGZVbNOxwovGlFKVL6Ag "Chef – Try It Online")
Tested with the Ruby interpreter. Makes alphabet soup.
I tried to be as compliant to the [original spec](http://www.dangermouse.net/esoteric/chef.html) as I could, so even though the interpreter I used lets you drop the `the`s in the `Pour contents` instruction, I haven't done so.
The mixing bowl is pretty expensive, so there might be a better approach. I tried using base conversion to encode the message, but unfortunately the spec doesn't clarify whether `Divide` uses integer or floating point division, and the interpreter I have uses the latter. There's also no modulo operator, which doesn't help either.
[Answer]
# Piet, 84 codels
*28x3, here shown with codel width 10.*
Created with [PietDev](https://www.rapapaing.com/blog/pietdev) ([zip](https://web.archive.org/web/20190408184542/http://www.rapapaing.com/piet/pietdev.zip)), tested with [npiet](http://www.bertnase.de/npiet/). The layout of the program is the following:
Yellow fill indicates codels where the path overlaps, orange fill indicates codels which must be the same color, for purposes of control flow.
To aid in the creation of this, I wrote a rudimentary interpreter for a stack-based language with piet-like commands, which I have dubbed "pasm" ([source](https://gist.github.com/primo-ppcg/d6ccb34016235d2e5841a38941c4f7c3#file-pasm-py)). The output from this interpreter (with [this input](https://gist.github.com/primo-ppcg/d6ccb34016235d2e5841a38941c4f7c3#file-hello-pasm)) is the following:
```
1 nop blu1 []
4 push 3 blu2 [3]
5 dup grn2 [3, 3]
6 add cyn2 [6]
7 dup ylw2 [6, 6]
8 mul grn1 [36]
9 dup red1 [36, 36]
10 dup blu1 [36, 36, 36]
11 add mgn1 [36, 72]
H 12 putc blu0 [36]
15 push 3 blu1 [36, 3]
16 sub mgn2 [33]
17 dup cyn2 [33, 33]
20 push 3 cyn0 [33, 33, 3]
21 mul blu2 [33, 99]
22 push 1 blu0 [33, 99, 1]
23 add mgn0 [33, 100]
24 dup cyn0 [33, 100, 100]
25 push 1 cyn1 [33, 100, 100, 1]
26 add blu1 [33, 100, 101]
e 27 putc cyn0 [33, 100]
28 dup ylw0 [33, 100, 100]
32 push 4 ylw1 [33, 100, 100, 4]
33 dup mgn1 [33, 100, 100, 4, 4]
34 add red1 [33, 100, 100, 8]
35 add ylw1 [33, 100, 108]
36 dup mgn1 [33, 100, 108, 108]
l 37 putc blu0 [33, 100, 108]
38 dup grn0 [33, 100, 108, 108]
l 39 putc ylw2 [33, 100, 108]
40 dup mgn2 [33, 100, 108, 108]
43 push 3 mgn0 [33, 100, 108, 108, 3]
44 add red0 [33, 100, 108, 111]
45 dup blu0 [33, 100, 108, 111, 111]
o 46 putc cyn2 [33, 100, 108, 111]
47 dup ylw2 [33, 100, 108, 111, 111]
48 dup mgn2 [33, 100, 108, 111, 111, 111]
53 push 5 mgn0 [33, 100, 108, 111, 111, 111, 5]
54 div ylw0 [33, 100, 108, 111, 111, 22]
55 dup mgn0 [33, 100, 108, 111, 111, 22, 22]
56 add red0 [33, 100, 108, 111, 111, 44]
57 dup blu0 [33, 100, 108, 111, 111, 44, 44]
, 58 putc cyn2 [33, 100, 108, 111, 111, 44]
59 dup ylw2 [33, 100, 108, 111, 111, 44, 44]
60 add grn2 [33, 100, 108, 111, 111, 88]
64 push 4 grn0 [33, 100, 108, 111, 111, 88, 4]
65 dup red0 [33, 100, 108, 111, 111, 88, 4, 4]
66 mul ylw2 [33, 100, 108, 111, 111, 88, 16]
67 dup mgn2 [33, 100, 108, 111, 111, 88, 16, 16]
68 add red2 [33, 100, 108, 111, 111, 88, 32]
69 putc mgn1 [33, 100, 108, 111, 111, 88]
70 push 1 mgn2 [33, 100, 108, 111, 111, 88, 1]
71 sub red0 [33, 100, 108, 111, 111, 87]
W 72 putc mgn2 [33, 100, 108, 111, 111]
o 73 putc blu1 [33, 100, 108, 111]
76 push 3 blu2 [33, 100, 108, 111, 3]
77 add mgn2 [33, 100, 108, 114]
r 78 putc blu1 [33, 100, 108]
l 79 putc cyn0 [33, 100]
d 80 putc grn2 [33]
! 81 putc ylw1 []
```
No pointer, switch, or roll commands are used. No codels are wasted either; in fact two are reused.
[Answer]
# HTML, 13 bytes
```
Hello, World!
```
The text is automatically inserted into the `<body>`, and is displayed.
[Answer]
# CSS, 30 bytes
```
:after{content:"Hello, World!"
```
Cascading Style Sheets (CSS) isn't a typical programming language, but it can do fixed output fairly well. This is done by creating a [pseudo-element](https://developer.mozilla.org/en-US/docs/Web/CSS/Pseudo-elements) after every element with the content `Hello, World!`. So only one element (`<html>`) is selected, this assumes that we're using the most basic HTML document, i.e.
```
<html><style>:after{content:"Hello, World!"</style></html>
```
This works in most major browsers, with the notable exception of Firefox, which applies the selector to the `<html>` and `<body>` elements. This is also why Stack snippets don't work, because there is always a body element that gets styled as well. Below is a slightly modified version to test.
```
* :after{content:"Hello, World!"
```
[Answer]
# Java, 79
```
class H{public static void main(String[]a){System.out.print("Hello, World!");}}
```
[Try it online!](https://tio.run/##y0osS9TNSsn@/z85J7G4WMGjuqA0KSczWaG4JLEESJXlZ6Yo5CZm5mkElxRl5qVHxyZqVgdXFpek5urll5boFQAFSzSUPFJzcvJ1FMLzi3JSFJU0rWtr//8HAA "Java (JDK) – Try It Online")
Earlier versions of Java may allow you to use a static block (51 bytes), but currently I don't know of a way to bypass the `main` method.
[Answer]
# [Whitespace](http://esolangs.org/wiki/whitespace), ~~192~~ ~~150~~ 146 bytes
Whitespace only needs spaces, tabs and linefeeds while other characters are ignored.
Which can be troublesome to display on here.
So in the code below the spaces & tabs were replaced.
And a ';' was put in front of the linefeeds for clarity.
To run the code, first replace . and > by spaces and tabs.
```
...;
..>>..>.>.;
..>>>>;
...>;
...>>>;
...>..;
..>>.>..;
..>>..>.>>;
..>>>>>>>;
...>..;
...>;
.;
...>>>.;
..>>...>>;
;
..;
.;
.;
>.>;
...>>.>.>>;
>...>;
..;
.;
;
;
..>;
;
;
;
```
[Try it online!](https://tio.run/##VY1RCsAwCEO/4ylytVEK299ghR7fxVWhQ9RAnnGe1@jPfbTuTtJIQK36JKDFNVIXhJ1G0j8o7vKy0CAtTBUqdwUgH8kJRJyZ@ws "Whitespace – Try It Online")
### Hexdump of code
```
00000000: 2020 200a 2020 0909 2020 0920 0920 0a20
00000010: 2009 0909 090a 2020 2009 0a20 2020 0909
00000020: 090a 2020 2009 2020 0a20 2009 0920 0920
00000030: 200a 2020 0909 2020 0920 0909 0a20 2009
00000040: 0909 0909 0909 0a20 2020 0920 200a 2020
00000050: 2009 0a20 0a20 2020 0909 0920 0a20 2009
00000060: 0920 2020 0909 0a0a 2020 0a20 0a20 0a09
00000070: 2009 0a20 2020 0909 2009 2009 090a 0920
00000080: 2020 090a 2020 0a20 0a0a 0a20 2009 0a0a
00000090: 0a0a
```
### Whitespace assembly code:
```
push 0 ;null
push -74 ;! chr(33)
push -7 ;d chr(100)
push 1 ;l chr(108)
push 7 ;r chr(114)
push 4 ;o chr(111)
push -20 ;W chr(87)
push -75 ; chr(32)
push -63 ;, chr(44)
push 4 ;o
push 1 ;l
dup ;l
push -6 ;e chr(101)
push -35 ;H chr(72)
p:
dup jumpz e
push 107 add printc
jump p
e:
exit
```
### Remarks:
I had to write a program just to calculate that adding 107 gives the optimal golf for the sentence. Since the bytesize that an integer takes in the code changes. : 4+int(abs(log2($n)))
The code will still run without the "e:" label & exit part on [whitespace.kauaveel.ee](http://whitespace.kauaveel.ee/). But that could make the whitespace code invalid on other whitespace compilers. So those bytes weren't golfed out from the solution.
**It Should Be Noted That**
As Kevin Cruijssen pointed out in the comments, by allowing an "exit by error" as per meta, the Whitespace can be golfcoded more to **126** characters.
```
..>>..>.>.;
..>>>>;
...>;
...>>>;
...>..;
..>>.>..;
..>>..>.>>;
..>>>>>>>;
...>..;
...>;
.;
...>>>.;
..>>...>>;
;
..;
...>>.>.>>;
>...>;
..;
.;
;
```
[Try it online!](https://tio.run/##K8/ILEktLkhMTv3/X0GBkxOIgZALxOTkBFIKEALKVoDIIBgg1ZxQ1SiKQPqgOmFKQSq5oJKcEI2cUAuAarn@/wcA "Whitespace – Try It Online")
**Assembly:**
```
push -74
push -7
push 1
push 7
push 4
push -20
push -75
push -63
push 4
push 1
dup
push -6
push -35
label_0:
push 107
add
printc
jmp label_0
```
[Answer]
# [Seed](https://github.com/TryItOnline/seed), ~~4154~~ ~~4135~~ ~~4117~~ 4078 bytes
Explanation, quite long, along with the description of the generation algorithm on my home page (as per request in comments): [link](https://palaiologos.rocks/posts/mersenne-twister/)
Possibly smallest one can create in finite amount of time.
**Feersum's generator has been outscored by 125 digits.**
```
18 1999111369209307333809858526699771101145468560828234645250681099656696029279480812880779443148152835266354745917034724622145903651417563371730237765283326056988244774110441802133624468817714160177386022056512108401823787027806425684398448067970193332644167536135089961308323052217690818659345826221618714547471817786824952177760705661213021136861627615564344797191592895410701640622192392412826316893318666484043376230339929937013414786228802341109250367744273459627437423609306999946689714086908789713031946200584966850579209651689981508129953665360591585003323062426849065928803791631705897655870676902001410564547259097078231664817435753967511921076054045034302323796976905054512737624542497156263914722954936458789312271946701667519720841308380062811251340113402138536813062807047486584549696366881131076129644333426157514410757991556230404583924322168740934746079177400690540383270574734570453863131129670312070568678426587468145691141064452504683450565188718043501125177371576228281599163415914580472091806809959254536307112226422637068036069837636348250796013947548859219492684001888592443619271863264913733271796439829896342322684180478385639971904415730730155249230972472713598001454701479081682503703435292522488015910406951417625194589254609756805750713606175216991897729604817653297756338264018378339186646236428245791304007449872675676823828828025054891324604572924113135541994460293993994930010757779465315482913805320566037487246911578188713647298779820394853314711728701462997760060773720597833413054385989484972761510228922232188763499675904892361201334056531237561182096332707820332381472154893517831468669407424867949853884550905603295504680929068346527584718316837786318710085149722173684889784734888358566137013072868037395888296895408992035862679921478330680631465096402120764369879221964359613565641652779510635224788673321444028128955312660697375763703507924497355056468329176678508797277505818080245055083627993568557883893217501909841992899324584338401263402065617507377073719573642373296064002058833488593469308722954567388945161866200094063588423591356962865924188962743278147095803148276100759174767606637848987740320689762075562393521992008413240632519860537097220403160035470139899869535541445941688033346042941342229305392639867768112643798588915164061012851035069872578424685533430920913310727097269791325370108354115267003538502506307401037702631576755065238836157990287620373910423088628131973441805618500402407032751005850768445522318425479521483938945040598642922742796671148454685792926662105094734939468210307429214048710552195412807154088634170043145174020299723624868716804740205833308025010299791473201989330179511900752421521748244324520372384555472905196933204791343923384985673930225356512632819977168423365518584516873151142795940198973519372718229122661025988052451376835210066645728260048500257088773609522352231828810506243886764860621803233068079848240668323783996022507908005888468315483796728648978952610219628600082949325089555677853995177602958596492703349550377871982505777660804519503438416790609328789548538308170189581940118961959513239411467871900221985235702327603132341245854941342838886675363828149587290416073764877392438738417021129652498464495269870868163299830870636019233313974206364225614175115905798645888824666280593535350493547833757379214088677125769505793280646751090271497879000895725329057103702349349795211071357094147037863458426851391499872003703049553149335378055054176480977774050198041879243243264959205957441742983643583697591926138999543475339555662645088503078864968452030049140027407987267835123806661736568594687416676322591834962173789578844522343172160526435025531896189408441645468352864002987706103448393710107805248652709736711528349633758515438315407447026188178510124322920110858766628704828773265703683997486487094455425009292414948853993709223752434073750917088611480305840639869649933404702780843770306859066070919534638022435125602050780767420448917941603557783974740312706609928585387278690009349321957381507513875981113699582062422293555869483805964659436085153933836036107786
```
[Try it online!](https://tio.run/##JdeJcdxIDAXQVDaEvhudzzqCzb@873PKtiyNSDbwL4D//fnz79@/vf7p773e@zxvtDfbnXNWe7Vrj3Peu7f31vva69Q@rUaNuc7aY7dTvb13tstOG2/ct6pVH1Xt@n7NvqrvUTNPmnvdtV@/ba471hnDM1@bZ/fV7z5z3n5nG/Pek3vmOG2fVzXWuncpYq1ebfQ5j49OVVfa6qf5f5YChut3H73Val2Vt24bt9pZY59a89VS37nvtv5mDvDEc/c8fe5WOumz1RyzbcXd8/RSZ7@5do3Ue3rdAHHX7Tm9juLedq2a23X8cbwegmadfsY9fe@zphbe7a/vN@rt1V3cz2p56BvzjQW0cWY/pTCHnrM0sWBylDPne@O96aa5@nLuCMZ4gMpDxDwQWuOq9Dl0zbvGPGETge@t47kqb5Webr730O7z0dqu9fx@t30jAAi6@OEtTL4HneNfwxxFNLUoCAEDoq@dNFRt3tdVDwHPPnsD/gQ/j8cQXALawDboL2Z6@uvq3NB/KOhgAIpjdK2fFSFg8J2X5yhuYfYGDo8C@u37AOxBYwyIvumMtDb7GDetBeE8@d1BEB@z1VRevY8NR5r2BV2lveppimwbcnFeTnH20Tyd9ZnaoEEwdKP3rvC@wiPUXjiGSkqvkDmjlboLAR5HGVTvp5ZOVpskBikiQpcDN/FOR@T5zNHHp6Q6txykJ1InusOjzlNBnOczN396L5osUtnta4wXYHOjEK3uF2KW/z3CVbB4rj4M/lAH1XlY3p2DG/yjMb/EN@dB229XOQ8RtPfW3avKjQB@UQB@6/sAMAeHSjnx1etTjvjRjTHeeAVMohy5K/VedDD9iy3i7H0TPQ2U2AUm2lRLqPtVVERAvt548qSimRwRLJoYQ1EtPaLgvC9PDiieltMjI8iXArlGenqTNxiCDblesLeokcyHH5NEvJgIkSCsFztyCoGBFGN6c05juFd3kBip0zS4/W0jWi3XiDjcejpzY3dutmfFlaTUtr9Eq7NIKGnp@O7O4ValzoTZ0eWqhCXy962Pa3V4aLmlRkMJ@cpZFN5RgeiMZPahthYteM5LG3HAXjDHhGwBb7KpS00YDcTk4Sh6sSNGfIrRgXUu2SmOHffpglVIhNs4@YuDiglT@5v0V6qh3vMWiDAjbwFF5Dy1GwfoimM/DQsvGULKEv8yHfkkA2eidSZsWyt0KlbGcimeNRPjUN2URwL3S8Wm@ej2zrf9CqWJ2WS6Ere8VAXVRnUzAj8pUjUnCcBwRErwApCyfb8zCjR9zAeVXZpyS4R2S0OaZn63ZtZpBTYnjgE350WZcQxP@GTHpbErYq9AkqHOgT4xbow2komTfWyuqdK5tZHNH885LmMQo4t4HOYjqpZCmXHsqgghHEFzz7350h8vESswIm0tugYqc37eBTbd1S82aRcxjJLZdjIOGt60iq0BhqBgomQKkrErv@liqIKygbplxEdJ/JDZvi4zNMMeSxWRijsFZipA@YtJDY700r5UHjktXjXAN@RCNXdRgVHzeV56GEds/TlI/D2kZOboh8OGHwWLbuhb@IoUDHGkTMPkzSLDjvsbtxaZQVDhJ3SPnYzNXsNDRk7mH72z5PgqwWiMnLosFcrhQkpKZYwUqyc8EdECfeY3@nWJEa7AZ890IJN0H20KKNFGQpRj/tJxshB9mayoZBl4GS0ZyxileKbhzq5OaGTXWEbMDGVuYGZEUy2nSdojBVb9NjX6AwZKjV@cOkrk@IWfU/OIG7icxXb42NlApGNMU5kYusz@xtCRWDJlZO/isgv@jMlPVVhoX@j175rMY4Sj0x5jMXuZ7NGGhaFnUVpZ56LhAAIk7WU1EAuM5x7kB3MzY0Tj2KNQ1A4sfNsdtVT/ttITiVofjcDM60xcBEAAFETyFcF/Vr3MkaIQU05gqNZWacdzjxGX7RTeWbmkteTXeOggDlCIUOMjFPxoEPIBFBIzSWCNIXfZibZfshBcevS8bJLy5mU3/kYooOLDShokLrPeJLdWQs0ZKa1/bmNDGYaxkb0URBQtQs3snmjnXEY2ZcmUcBOmiUzOz2TMOBFHONL7t0tV1lxBax8Z2ZF2hkYhDstGoBgKXL4zwrczFM5VEvJ7JiiU5W3AtpatTAEzl1CMKLInfQYUVwD5tumMQqFtdcFrFvTsbStQZjfCUkVe41t4Mu0BsrJGx5JWVANecL3UZxkBf1ZkrpyPbPMBt7NMXhr48WVvrSx/yf0VxeNWyORPA@H@Ql8wgzuaD23XpmSv/HZekMjIbIqGE6EIbQEdBuToyE7gqjg8@7b0fJ8LezYJeLzs434Zz@wsbOIlW@lLvLRvS2nrGxHuVZLXkUyEbCjeRcg4EZmIR1fPAIo5vg1K4urDmuhadpUm5pKvL0HL2tYEq72RbimzpUQkxpxYEPKxuD6tsPU5jaTVhEiH3d/WQvYmekX3Ga0ZOokHL1pIRACTGMaekMkbzXhgdk8gWPRtTwyUivhEc5GOTBLp7v8CiF/qGz2ZAkleWZfkAiXsPvtVZisMZnIrr3wri4U9YPdsKvFItqwka8/bXpK7f9s1aDDA9vfj2xJNcvRlXwb4iemyxtMcgkSM8GzZNcwwcq3PShk2IzuNJ65IVEz2WP4kRGGGzvZNkzjtZQ1av/dJ4/eG10AGP5mNkG0agdOKEGAtOdhLnwYC1a6shDeTy@xg0IqYMxy91OQRme07phRVeUlreXXI@M8sz7sYefql4Pq9qTPX@N7CMvdQ756V95ukglltm8nipE0h6nuTqGWn@vv3fw "Seed – Try It Online")
## Original, 4154 byte version
Added per request of @JoKing, because the 1st program doesn't *quite* run on TIO, albeit being valid.
```
20 77698190481213510983405846204529755428212736563278528088055816123655499433757607718113585773285686740433752335768949721107461077652705328567448384490378909463204984642622585570301449419608763821501335954761638946551568252142160714228369356054944595121742743720935369219143086698092657062614382519069928478344861416117079283276656675368390764675728501797178208908097054412833019383889935034413095990596139618411133857423995278221670378808372393943846302426674985203826030563290800228881174929701934609803807325868775242909948272754141956168876233403760199007405891058308908050926690654387065882097924294620229833663324754801060691573338185912369627367088050915813931912943122729210762147280440619571047157836177316082899933374851699282897590433145623725705072835054748369992455883804733164985993447304652512229557984322495162682327137071900307763332392727562988633724175094951314863886096190608268953115914497741446723188169519334729165647294618083444761551231012944903572063441813639201051793052623561949314826491616145873848990439549320951496534538450810083853945092224500179417650727351532486362656533602860500906935826231374501097567347929533018944533000919137863885267937690665655625569011036163950983389810112758403211861147501289650757555111271813737813381172074709337306647481507917983021055643749698971365256395367215437223669891280521155247529741719633106765965869860677198632388808752014013939448563313855130972968670015202479226496876067874099463222366536167126653600056389712632892652810365218798697007191747287017174284819764736012653205048166550645507761123345279502597627995423826537299795220169894222867163817508592362092945387317777666016102146798532337718546431888424995701016828542559577710937459975677354300708252448630110787487122698124054544454425586794841157136743408274159313823745226919626156949004386804874236325506583268311452185182143521552429596087556634158778951670223004413763782647825362665491934988477225698133609360969370513836064317152213804169538880632390908441210809806024082600637872813704781431414342781727628446451808751293046212690472851527294326981763969926510021099532791692362104324026231160941956411410511639925420026544463125250979130259151326444714248961523031316570018708849878676230362246913063109584502143502908906243190007062857721367402065760878808920961082444422470813023453274563914735545463757909757689866565064353853099958949763412521666109346825939993377745919874506439752272141853783745051726268592621080457687000431023453539135927140364910898906534604541224314820195082362228787083990333757268808864746297304451768935814651205074884015268982492445996542040655715230139673520569765431617018824427859214902954216246257690105154030408059145566852643855789351907818461502260430297487602982850090037405732117988720732457199005151517240766953718440639691354185802798689950155164379549518496065038927905828230066053603755553745353618846804435103593395141938947781375633374976924393453162350331593801284839409264892975739791751842620029351535320807733966984270102067017902086335370470815153908942490581427972998999752666174807935897314584088695849094389002316139005810918748032068307783088481430339303809949409414892479892121893571274086727250767713365523021125610242269894861374297866741571608166536165735922984579027986499758294460652554897534526492251140681138244025665400003029337114012766773010641359450599171473565675885966777145500248501370644599274741842644014722083732709145488157998306684831419559774212264003518406013032514468522158218837161285401631773099549510145156007147884565387852623860047153609138110997222297132678660783411624002400927435687937355446057878202312894093195453248164648271580944753933355967626542678764854079218206499479071658357103085513937246462858404881973219571392564909528645166637501279457604649906515968389831094896970731573714836150178126997674563415266672131632765794599548356902607125568792417432226125654028873443580337866760487651905138461301986816386866811155111486155341154153322710638921116465132825486519667178335471102213200521032618562169530188826434060179505699797068436325168526618824444305122475837890944742004331675952611756641739756206337285946
```
[Try it online!](https://tio.run/##LdeJcSU5DAPQVDYEHdSVz04Em395H9ozVfZ891dLJAiA1H9//vz78zPaP@fsd/trdfvoc/X27qy2bu3Rao131qpxRx9n7rXnOHeN2@5ta92@@/B01Xs151lnt3P67fa565w57tp3n2rft2NOK@6rd0bv7dT26@w1Tlvf0lN15616bZ772ivHtXpCqbHHsOc6bbZuRfW32z17imy1bue36uzugdfW6g4ea/QaXUz@G3fuN9dugq2yWranxql5RvOFb0d/vWa7GyDtje2wPbZHdgLQfm/cOtCp66nc@2nHM5hs0OxjkztfO7t8PjJq/bzTzx1NOvaUaFX3hiTelOt9jm527LO99V5bb/fp51aH4oRijfkejO6Qygky0Bf0fBPosJltgAd4T2WaYDeMUqkc2SR@FcS3SplTa6uwZU151t33KExZq4R3nHFWye0tUF74qlk5c3vzNSVDjNf9mr8ZreC0YbOEAq515fqAYscQaAxsmnvPOcrOt/W2AdnXmZLrd70Q6O2Q63ykar68IJiKYY/Zh6CUBqqqCdRW1bYAT291bKSuHdWU@Q5wPhufuqt/5fLkrBf69VqSOUNRV7MN2BGmwgoLC5mVw45W7iBpo/JXQybVHxJBPlScYxTyIMYdCt8nDiAHyFHZ2eryobhlfj04o/qRVV4ShEceNxUGmojJYc3e4YDU58Aed8bsara9IRs5v45e@Z9iUvyqUB3JLWxBKYpBuLbDJOhtQYB6oR8q0A7idyEkgCE93MXgdQ/@wAw@1POIzZH19pq1fLPa7c1xd2FaKi311cJpKe2gePgF6SYrgCwvzt2G/CyLYNhADgeSFzkLWI6EUHFFAjdK9MFi1cbsgCNcUZ@QKjsC0s9rDGNG3m/FoKhcbJ0pMao22QlJoodTlDyxLb61elYEkGPzyIkQBhYfivfMCaEAAzlPVkiNZ07jCVB4uANK5c@p@Mlp4hYIm@8cBFqlW6E2cQGFKeFP29ARxLUM2zmi/xHjRrmWMrDWP/niaV6A8IoBqHDsEsQWjeCUYpFodrnE9z5L/CJYQeP08X2C4Irz5W9OGu8aN4AJ8Epsk35oygZQnw2ceJ/a98esaA9s9hnq5pktV9skEUpDEAf5D@DHstwnZBnxmQWNR@1ryCmYsFnVP3HhkJ6KhIpVKIpQRHr829txrJ@cVRq5HJCusdh8iH@LwugbYXgQFy0M8Lc1yoZJ7@MR7jHrxjX4fCx5hiOB6YJhpKkNdlUcNz/2EBmPY6wrdeX85V1lWy8lGNk67yki18c5qqIMFgmU2DBoAwzzI1uiraC7ug5U08f1@ej6@hIS0SInOxrZim8rmt34PJc4EaFfK6phnS@2zC7qYNdK5NHRyw8NMSzh@SPwcDx9IE4Vf/goFWqx73bTWnrajGfoE3dpLaepeXzKkSLl7jLXT0hBNb2l1P1jJiuJ4en1BBemUHfcl@klKJG/uOo2JEQpisQBmclXZXbMCdqnd2b8viYC7IoPRbhvqKQXdyqyGTtlpVdgPmJ1SUKFs2nWTEkFIKYwPX2YV6Q9AIlJpCvhNjfaedlWfCt29RWipe8xjyFVBWxp4hlGxlfzxiQzptyvjXJJBwHKubjLF26iif0hRnTPU@YKiXbGmxcLywhzP29KRVbsERQiyGCTqmfuQPKwtTKFUHraEgLjLi@IGXrTVultALKDNpbHHHuktRDO/mpZOU7@wO2/gTFj45Umw0VmvFwayXelswsU9@vzeS2bBFMaojzBTxxtfnOaIzLDxf40qrQ5HEhiHJssMSFdsiAeL0rCNDkyN/E1VdSCtcOvRBlXYOQFLpM5gLZp9wbUDIt6NyGNeIau6bgVbw8plgTsxEbBHMXE@ytmeBKI6iGpAYc/0yUEWlw2bqi3Zrpq6buZSU46AC@5cXcsFFrGFUf0IFqGh6iFyWR4CItBGNxvG7FHPVDnYMKx/rRCgmC8kjQogdpc5sAomHfFb2e6y0rJMjlKtuISlfFZbeZMH82E90g62ovNp6lIXXVe6tjTlZUj9nPTtswirzJPYX/G7jMjjpNQkIFw3tdtY9OGN4PKSx@CMTCxOq4O55ahY31qR@a8EDnEUltKK5d4dgYl9AtLIar9qTsaZCao8CJ6ygAuAwenpDN46imvx2G13MYDhZFJMI1EdUQ0M1jqUkmEz0hEF/ObMaWkjFm5KBjv8Sutceb@MNJ56SZdoT7vfpmxIQaIm9k2nk21/W/jAw5ioUFFlF8NKxndDEOpG6euzH5pXb5iq5xIyD1OjwTOwlW6amGV2uTrnkEesplSKyKLIp8afC5A8Q5A6Kw5YSxoKkM@tPenDdkJNfVyRKbVkVGdl7QwnJyk8TJn4Lpyf4P2ytg30rGEM1Nt7s2FNJsMgzd@Ly8cE6T7ln6oL6aVxnY@rjoqF560eB4Pk51ue7/BzwTyzclpJj0DkJfEBbsTww26LXeaHnEmIarKrcj9KWNYzA@gFJlbDCaYLtSWta76Jj@S2bk4iFHJTUIzE7isYtPxikwuVojaPKNZtlQKKwSbVpo5HoUyAL0My7aTIhCC1ouwM@qbZzUTjDTXpF0h7vyGPR09dl7ZVNmJCS3ZVXpCuojBB63RBTS5KeRKdtPfSPFz@OqfDNIeem63qPVSStWamTtHro8ZQW9uNdSS@WuHqzJytzLPAosg5kfUnVlhx7vStHlXbnoMJiOR2S4E7N9cGn5zkEwjQnBvAGHLDEcIwTTtUO@wzGY2FjZYVZJExMoPdBkkYT5G5G8YiOlmspgfgzKwreQJAmz7ppf@Wez@NWdxt9xs1Oz@vW9j72jfbQnVYZ0rLqFIO91q54IxMxYYQ39@/gc "Seed – Try It Online")
[Answer]
# [Hexagony](https://github.com/mbuettner/hexagony), ~~37~~ 32 bytes
>
> **Notice:** I'll be giving a bounty of 500 rep to the first person who finds a valid solution in a hexagon of side-length 3 or a provably optimal solution of side-length 4. If you can't find such a solution but manage to beat my score in a side-length 4 hexagon (by getting more no-ops at the end of the program, which can be omitted from the source code), I'm willing to give out a smaller bounty for that as well.
>
>
>
```
H;e;P1;@/;W;o;/l;;o;Q/r;l;d;2;P0
```
[Try it online!](http://hexagony.tryitonline.net/#code=SDtlO1AxO0AvO1c7bzsvbDs7bztRL3I7bDtkOzI7UDA&input=)
I proudly present my second 2D programming language, *and* (to my knowledge) the first ever 2D language on a hexagonal grid.
The source code doesn't look very 2D, does it? Well, whitespace is optional in Hexagony. First, the source code is padded to the next [centred hexagonal number](https://oeis.org/A003215) with no-ops (`.`). The next such number is 37, so we insert five no-ops at the end. Then the source code is rearranged into regular hexagon:
```
H ; e ;
P 1 ; @ /
; W ; o ; /
l ; ; o ; Q /
r ; l ; d ;
2 ; P 0 .
. . . .
```
This is also runnable. [Try it online!](http://hexagony.tryitonline.net/#code=ICAgSCA7IGUgOwogIFAgMSA7IEAgLwogOyBXIDsgbyA7IC8KbCA7IDsgbyA7IFEgLwogciA7IGwgOyBkIDsKICAyIDsgUCAwIC4KICAgLiAuIC4gLg&input=)
Hexagony has a bunch of pretty funky features, including 6 different instruction pointers and a memory layout which is the line graph of a hexagonal grid, but this code uses only one IP and one memory edge, so let's not worry about that for now.
Here is an overview over the relevant commands:
* Letters just set the current memory edge to their ASCII value
* `;` prints the current value, modulo 256, as a byte to STDOUT.
* `/` is a mirror which behaves as you'd expect (causing the IP to take a 120 degree turn).
* Digits work as they do in [Labyrinth](https://github.com/mbuettner/labyrinth): they multiply the current cell by 10 and then add themselves.
* `@` terminates the program.
Now the final catch is that the source wraps around all 3 pairs of edges. Furthermore, if the IP leaves the grid through one of the six corners, there are two possible rows to jump to. Which one is chosen depends on whether the current value is positive or non-positive. The following annotated version shows where the IP re-enters each time it leaves the grid:
```
H ; e ; -> 1
5 -> P 1 ; @ / -> 4
3 -> ; W ; o ; / -> 2
1 -> l ; ; o ; Q /
4 -> r ; l ; d ; -> 5
2 -> 2 ; P 0 . -> 3
. . . .
```
So if we remove all the direction changes, this program boils down to the following linear code:
```
H;e;l;;o;Q2;P0;W;o;r;l;d;P1;@
```
What's with `Q2`, `P0` and `P1`? Letters are printed easily because we can just set the edge to the corresponding value. For the comma, the space and the exclamation mark, that doesn't work. We also can't just set their value with `44`, `32`, `33`, respectively, because the memory edge is non-zero to begin with, and due to the semantics of individual digits that would wreak all sorts of havoc. If we wanted to do that, we'd have to reset the edge value to zero with something like `*`, `+`, `-`, `&` or `^` first. However, since the value is taken modulo 256 before being printed we don't have to set the values exactly to 44, 32, or 33. For instance, `Q2` will set the edge value to `81*10 + 2 = 812`, which is `44` when taken modulo `256`. This way we can save a byte on each of those three characters. (Unfortunately, it's never possible to get there with a single digit from the value the cell already has. Amusingly, where it *does* work is the `o` in `World`, because that can also be obtained from `W9`.)
[You can use this CJam script](http://cjam.aditsu.net/#code=q%3AC%3B'%5B%2C_el%5EA%2Cm*%7B_Ab256%25c%5C%2B%7D%25%7B0%3DC%26%7D%2C1f%3EN*&input=%2C) to find all letter-digit combinations that result in a given character.
I'm not sure whether this is optimal. I doubt it's possible to do it in a hexagon of side-length 3 (where you'd only have 19 characters available), but it might be possible to solve it in a hexagon with side-length 4 with less than 32 commands, such that there are more no-ops at the end of the grid.
[Answer]
# x86\_64 machine code for Linux, 32 bytes
When Linux starts a new process, all the registers (except RSP) are zero, so we can get RAX=1 by only modifying the low byte. The x86-64 System V ABI doesn't guarantee this, but it's what Linux actually does. This code only works as `_start` in a static executable.
```
0000000000000000 <_start>:
0: e8 0d 00 00 00 call 12 <hello>
5: 48 65 6c 6c 6f
a: 2c 20 57 6f 72
f: 6c 64 21 5e 40
0000000000000012 <hello>:
12: 5e pop rsi
13: 40 b7 01 mov dil,0x1
16: b2 0d mov dl,0xd
18: b0 01 mov al,0x1
1a: 0f 05 syscall
1c: b0 3c mov al,0x3c
1e: 0f 05 syscall
```
The call instruction pushes the next address, which contains the hello world string, onto the stack. We pop the address of the string into `rsi`.
Then the other arguments are set up for a `syscall` to `sys_write`, which prints the string.
The program terminates with a `syscall` to `sys_exit`. `sys_write` returns the number of bytes written, so the upper bytes of RAX are zero after the first `syscall` (unless it returned an error), so `mov al, 60` gives us RAX = `__NR_exit` in only 2 bytes.
You can make this program segfault by closing its stdout (`./a.out >&-`), so `sys_write()` will return `-EBADF`, the second `syscall` will return `-ENOSYS`, and then execution will fall off the end. But we don't need to handle `write()` errors gracefully.
[Answer]
# C, 30 Bytes
```
main(){puts("Hello, World!");}
```
[Try it online!](https://tio.run/##S9ZNT07@/z83MTNPQ7O6oLSkWEPJIzUnJ19HITy/KCdFUUnTuvb/fwA "C (gcc) – Try It Online")
Fairly vanilla, but I can't think of a commonly compilable way to do it any shorter (unless maybe some kind of raw asm trick might work?). Still, beats most esolangs!
[Answer]
# [Fourier](https://github.com/beta-decay/Fourier), 15 bytes
***[BIG CHANGES to Fourier!](https://github.com/beta-decay/beta-decay.github.io/commit/f56ae30caea38dd8a9c36afe7a399b6be4b4d818)***
```
`Hello, World!`
```
[**Try it on FourIDE!**](https://beta-decay.github.io/editor/?code=YEhlbGxvLCBXb3JsZCFg)
Yes, the days of typing out the ASCII code of each character are gone forever: Fourier now *kind of* supports strings. When you enclose a string in backticks, that string will be outputted.
Note that you can't do anything other than output that string: you cannot store it in a variable, it is not stored in the accumulator and there are no string manipulation tools.
---
Here, you can find the train wreck that was *old* Fourier. ;)
```
72a101a+7aa+3a44a32a87a111a+3a-6a-8a33a
```
[**Try it online!**](https://tio.run/nexus/fourier#FcfBCQAwCATBgkTIqUTb2f6LMGR@sx3oCGuwpIoMppH07xcfMtl9)
Now, some of you will probably have [met Fourier before](https://codegolf.stackexchange.com/questions/55384/golfing-strings-in-fourier) and may be fairly familiar with the language. The whole language is based upon an accumulator: a global variable which pretty much all operators use.
The most important part of the code is the `a` operator. This takes the numerical value of the accumulator and converts it to a character using the Python code `chr(accumulator)`. This is then printed to STDOUT.
Unfortunately, I haven't had the chance to use Fourier yet (*nudge nudge*, *wink wink*), mainly because of its lack of strings and string operators. Even so, it's still usuable for many other challenges (see the examples section of its EsoLangs page).
Note that this is shorter than my entry into the [Esolangs list](http://esolangs.org/wiki/Hello_world_program_in_esoteric_languages#Fourier) because I didn't actually think that I could golf it any more. And then, when writing the Fourier string golfing challenge, I realised I could go quite a bit shorter.
## Note
If you were wondering about variable syntax, Geobits wrote a program which uses variables *and* is the same length:
```
72a101a+7aa+3~za44a32a87aza+3a-6a-8a/3a
```
[**Try it online!**](https://tio.run/nexus/fourier#DcfBDQAgCACxgQxRwAjr3Bo8XB3trx2GLmUEDL/F3riRQf0jB0mm0/0A)
[Answer]
# [C--](http://www.cs.tufts.edu/%7Enr/c--/index.html), 155 bytes
```
target byteorder little;import puts;export main;section"data"{s:bits8[]"Hello, World!\0";}foreign"C"main(){foreign"C"puts("address"s);foreign"C"return(0);}
```
Unfortunately, the only known C-- compiler, [Quick C--](https://github.com/nrnrnr/qc--) is no longer maintained. It's a pain in a neck to build, but it *is* possible...
[Answer]
# Java 5, 61 bytes
```
enum H{H;{System.out.print("Hello, World!");System.exit(0);}}
```
This is valid in both Java 5 and Java 6. This won't work in Java 4 or earlier (because `enum` didn't exist) and will not work in Java 7 or after (because this solution uses a bypass[1] that was "fixed").
```
enum H { // An enum is basically a class.
H; // Static initialization of the mandatory instance, invoking the default constructor.
// Happens before the existence check of "main"-method.
// No constructor means default constructor in Java.
{ // Instance initialization block.
// Executed in each constructor call.
System.out.print("Hello, World!"); // duh!
System.exit(0); // Exit before the JVM complains that no main method is found.
// (and before it writes on stderr)
}
}
```
## Rough equivalence in Java as usually written
The above code is roughly equivalent to the following one.
```
class HelloWorld {
public final static HelloWorld INSTANCE;
static {
INSTANCE = new HelloWorld();
}
public HelloWorld() {
System.out.print("Hello, World!");
System.exit(0);
}
}
```
## Proof of correctness
```
$ java -version
java version "1.6.0_45"
Java(TM) SE Runtime Environment (build 1.6.0_45-b06)
Java HotSpot(TM) 64-Bit Server VM (build 20.45-b01, mixed mode)
$ javac H.java
$ java H
Hello, World!
$
```
---
1. The bypass consists of the static execution of code when the class is being linked. Before Java 7, the `main`-method-containing class was no exception to the static initialization code. Afterwards, static initialization was delayed until the `main` method would actually be found.
[Answer]
## Malbolge, 112 bytes
```
('&%:9]!~}|z2Vxwv-,POqponl$Hjihf|B@@>,=<M:9&7Y#VV2TSn.Oe*c;(I&%$#"mCBA?zxxv*Pb8`qo42mZF.{Iy*@dD'<;_?!\}}|z2VxSSQ
```
I'm going to see if there's a shorter one. Got a better computer since last time, so I can generate quite a bit faster.
For show, here's "Hello World!" without the comma.
```
(=<`#9]~6ZY32Vx/4Rs+0No-&Jk)"Fh}|Bcy?`=*z]Kw%oG4UUS0/@-ejc(:'8dc
```
[Answer]
# [Unreadable](https://esolangs.org/wiki/Unreadable), ~~843~~ ~~755~~ ~~732~~ ~~666~~ ~~645~~ ~~629~~ 577 bytes
>
> '"'""'""'""'"'"'""""""'""'"""'""'""'""'""'""'""'""'"'""'""""""'""'""'""'"""'""'""'""'""'""'""'""'""'""'""'""'""'""'""""""'""'""'"""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'"'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""""""'""""""""'"""'""'""'""'""'""'""'""'""'""'""'""'""'""""""'"""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'"""'"'"""""""'""""""""'"""'"'"""""""'"""'"'"""""""'""'""'"""'"'""'""'""'"'""'""'""'"""""""'""'"""'"'"""""""'""'"""'"'"""""""'""'""'""'"""'"'""'"""""""'"""
>
>
>
Unreadable programs are supposed to be displayed with a variable-width font, so they honor the language's name. I'm slightly disappointed that my more sophisticated approaches turned out to be a lot longer. Loops are insanely expensive in Unreadable...
[Try it online!](https://tio.run/nexus/unreadable#@6@upK4ER2AOCEAEkKVQlaGqw68aC0LRSoI@JNupjqBuQjBI1KdOY4SIHHRnquPiIWvEFnqoUU1AAM0wuI3//wMA "Unreadable – TIO Nexus")
### How it works
Unreadable has only ten functions; six of these are used in this code:
```
'" p Print.
'"" + Increment.
'""" 1 Return 1.
'"""""" : Set.
'""""""" = Get.
'"""""""" - Decrement.
```
After using my single-character notation and adding some whitespace and comments, the above code looks like the following. Multi-line statements are executed from bottom to top.
```
p+++ Print 3 + variable 2 (o).
pp Print variable 2 two times (l).
:+1+++++++ Save 8 + variable 3 in variable 2.
p+ Print 1 + variable 3 (e).
:++1+++++++++++++ Save 13 + variable 4 in variable 3.
:+++1+++++++++++++++ Save 43 + variable 0 in variable 4.
p++++++++++++++++++++++++++++ Print 28 + variable 0 (H).
:-1++++++++++++ Save 44 in variable 0.
:1+++++++++++++++++++++++++++++++1 Save 32 in variable 1.
p=-1 Print variable 0 (,).
p=1 Print variable 1 ( ).
p=+++1 Print variable 4 (W).
p+++ Print 6 + variable 2 (r).
p+++=+1 Print 3 + variable 2 (o).
p=+1 Print variable 2 (l).
p=++1 Print variable 3 (d).
p+=1 Print 1 + variable 1 (!).
```
I've generated the actual source code by running the uncommented version of the above pseudocode through [this CJam program](https://tio.run/nexus/cjam#fY89CsAwCIX3nELSIdCHg2vBK3TpHTLb@w@p@WkhHfLA588ngiWl@zrBkQxCdCjHvKWY94xSDEAgMnNzBkFXa33@FpV9cFoZ7AcnXO8sNG36MZYFdS5YS4IpV6vR@/GlJ224WyMqDw "CJam – TIO Nexus").
[Answer]
# [JSFuck](https://esolangs.org/wiki/JSFuck), ~~6293~~ ~~6289~~ 6277 bytes
This may get a mention as one of the longest "shortest *Hello, World!* programs" (actually I do not know if this is optimal, but it's the shortest I managed to get).
**Warning: only works in Firefox and Safari**
```
[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]([(![]+[])[+!![]]+(![]+[])[!![]+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[!![]+!![]+!![]]]+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]()[+!![]+[!![]+!![]]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]]+[])[!![]+!![]+[+[]]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[+!![]])()(!![])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(![]+[])[+!![]]+(!![]+[])[+[]]](([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]]+[])[!![]+!![]+[+[]]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]]+[])[!![]+!![]+[+[]]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]]+(![]+[])[+[]])())[+!![]+[+!![]]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]+(![]+[])[!![]+!![]]+([][[]]+[])[!![]+!![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]]+[])[!![]+!![]+[+[]]]+(![]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]])()((+(+!![]+(!![]+[])[!![]+!![]+!![]]+(+!![])+(+[])+(+[])+(+[]))+[])[+[]]+![])[+[]]+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]()[+!![]+[!![]+!![]]]+(+[]+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]))()
```
There is also a slightly longer version (+4 bytes) that also works in Chrome and Microsoft Edge:
```
[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]([(![]+[])[+!![]]+(![]+[])[!![]+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[!![]+!![]+!![]]]+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]()[+!![]+[!![]+!![]]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[+!![]])()(!![])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(![]+[])[+!![]]+(!![]+[])[+[]]]((![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]]+(![]+[])[+[]])())[+!![]+[+!![]]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]+(![]+[])[!![]+!![]]+([][[]]+[])[!![]+!![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+(![]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]])()((+(+!![]+(!![]+[])[!![]+!![]+!![]]+(+!![])+(+[])+(+[])+(+[]))+[])[+[]]+![])[+[]]+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]()[+!![]+[!![]+!![]]]+(+[]+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]))()
```
For those unfamiliar with JSFuck, it's about writing JavaScript as if there were only six characters, and it can get pretty crazy at times.
This table shows how the characters used in the *Hello, World!* program are encoded in JSFuck. The plain text code is just `alert("Hello, World!")`.
```
+----------+--------------------------------------+---------------------------+
|JavaScript| write as | JSFuck |
+----------+--------------------------------------+---------------------------+
| a | (false+[])[1] | (![]+[])[+!![]] |
| l | (false+[])[2] | (![]+[])[!![]+!![]] |
| e | (true+[])[3] | (!![]+[])[!![]+!![]+!![]] |
| r | (true+[])[1] | (!![]+[])[+!![]] |
| t | (true+[])[0] | (!![]+[])[+[]] |
| ( | ([]+[]["fill"])[13] | 114 bytes |
| " | ([]+[])["fontcolor"]()[12] | 539 bytes |
| H | btoa(true)[1] | 1187 bytes |
| o | (true+[]["fill"])[10] | 105 bytes |
| space | ([]["fill"]+[])[20] | 107 bytes |
| W | (NaN+self())[11] | 968 bytes |
| d | (undefined+[])[2] | ([][[]]+[])[!![]+!![]] |
| ! | atob((Infinity+[])[0]+false)[0] | 1255 bytes |
| ) | (0+[false]+[]["fill"])[20] | 114 bytes |
+----------+--------------------------------------+---------------------------+
```
Here the strings `"fill"`, `"fontcolor"`, etc. must be written as `"f"+"i"+"l"+"l"`, `"f"+"o"+"n"+"t"+"c"+"o"+"l"+"o"+"r"` to be encoded.
The global identifiers `self`, `atob` and `btoa` get written like `Function("return self")()`.
`Function` itself should be `[]["fill"]["constructor"]`.
The comma `","` is tricky, I'm not 100% sure how it works but it uses the `[]["concat"]` function to create an array.
I'll post an update when I have time to do more tests.
---
I encoded this using JScrewIt - credits to [GOTO 0](https://codegolf.stackexchange.com/users/12474/goto-0) for creating such a sophisticated tool:
* Open Firefox *(You can choose any other browser(s), but Firefox only code is the shortest.)*
* Navigate to **JScrewIt**: <http://jscrew.it>
* **Input:** `alert("Hello, World!")`
* **Executable code:** checked
* **Compatibility:** Only this browser
This differs from my answer to [this question](https://codegolf.stackexchange.com/questions/17950/jsfuck-golf-hello-world) for the presence of the comma after "Hello".
Interestingly, the ES6 syntax
```
alert`Hello, World!`
```
takes even more bytes to encode (+1500 or so) because of the higher complexity of encoding two backticks rather than `("` and `")`.
] |
[Question]
[
This challenge is to score a Cribbage hand. If you don't play Cribbage, you've got some learning to do. We play with a standard poker deck, and a hand consists of four cards plus the "up card". There are two types of hand: normal, and a 'crib hand'.
Cards come in the format `vs` where `v` is one of: `A23456789TJQK` (T for ten) and `s` is one of `SCDH`. A hand will be given in the form (for example)
```
AS 2D 3H JS | 4S
```
where `4S` is the up card. A crib hand will have the format
```
JD 3C 4H 5H | 5S !
```
Face cards have a value of 10, and the ace has a value of 1. Scoring is performed as follows.
* Fifteens: for each subset of five cards whose sum is 15, add two points.
* Pairs: for each pair of cards with the same rank (not value), add two points.
* Runs: for each maximal run of consecutive cards of length longer than 2, add the length of the run in points.
* Flush: if all five cards are the same suit, add five points. Otherwise, if all but the up card are the same suit, add four points. If this is a crib hand, the four-point variant is not counted.
* Nobs: if there is a jack in hand with the same suit of the up card, add one point.
**Notes:**
* Triples and fours of a kind are not special -- there are three pairs in a triple, so a triple is worth 6 points.
* Runs can overlap. For example, `AS AH 2D 3C | 2C` (a double double run) has four runs of length 3 and two pair, so is worth 3+3+3+3+2+2 = 16 points.
* Only maximal runs are counted, so `KS QD JD TC | 9S` is worth 5 points, since it is a run of 5. The sub-runs are not counted.
**House Rule:**
It's impossible to score 19 points in a hand. Instead of zero, report a score of 19.
**Examples:**
```
5S 5H 5D JS | KS
21
AS 2D 3H JS | 4S !
9
JD 3C 4H 5H | 5S
12
9S 8S 7S 6S | 5H !
9
9S 8S 7S 6S | 5H
13
8D 7D 6D 5D | 4D !
14
8D 7D 6D 5D | 4D
14
AD KD 3C QD | 6D
19
```
This is code golf. Shortest solution wins.
[Answer]
## C, 364 388 chars
It's big and ugly (though not as big as it once was):
```
char*L="CA23456789TJQKDHS",b[20],p[15],r[5],s[5],v,i=4,t,m,q;
g(j){++p[r[i]=strchr(L,b[j])-L];s[i]=strchr(L,b[j+1])-L;}
f(j,u){u==15?v+=2:++j<5&&f(j,u,f(j,u+(r[j]>9?10:r[j])));}
main(){gets(b);for(g(14);i--;r[i]^11|s[i]^s[4]||++v)g(i*3);
for(f(i,0);++i<15;v+=q?q*q-q:t>2?t*m:0,t=q?t+1:0,m=q?m*q:1)q=p[i];
while(++t<5&&s[t]==*s);v+=t>4-!b[16]?t:0;printf("%d\n",v?v:19);}
```
(Line breaks were added to make it easier to read; those aren't included in the above tally.)
The problem description didn't specify if the code needed to check for invalid input, so naturally I assumed that the program was free to misbehave at will if the input, say, contained extra whitespace.
Here's the ungolfed version:
```
#include <stdio.h>
#include <string.h>
/* A-K correspond to values 1-13. Suit values are arbitrary.
*/
static char const *symbols="CA23456789TJQKDHS";
/* Used as both an input buffer and to bucket cards by rank.
*/
static char buf[20];
/* The cards.
*/
static int rank[5], suit[5];
/* The cards broken down by rank.
*/
static int buckets[15];
static int score;
static int touching, matching, i;
/* Read card number i from buf at position j.
*/
static void getcard(int j)
{
rank[i] = strchr(symbols, buf[j]) - symbols;
suit[i] = strchr(symbols, buf[j+1]) - symbols;
++buckets[rank[i];
}
/* Recursively find all combinations that add up to fifteen.
*/
static void fifteens(int j, int total)
{
for ( ; j < 5 ; ++j) {
int subtotal = total + (rank[j] > 9 ? 10 : rank[j]);
if (subtotal == 15)
score += 2;
else if (subtotal < 15)
fifteens(j + 1, subtotal);
}
}
int main(void)
{
fgets(buf, sizeof buf, stdin);
score = 0;
/* Read cards from buf */
for (i = 0 ; i < 4 ; ++i)
getcard(i * 3);
getcard(14);
/* Score fifteens */
fifteens(0, 0);
/* Score any runs and/or pairs */
touching = 0;
matching = 1;
for (i = 1 ; i < 15 ; ++i) {
if (buckets[i]) {
score += buckets[i] * (buckets[i] - 1);
++touching;
matching *= buckets[i];
} else {
if (touching > 2)
score += touching * matching;
touching = 0;
matching = 1;
}
}
/* Check for flush */
for (i = 1 ; i < 5 && suit[i] == suit[0] ; ++i) ;
if (i >= (buf[17] == '!' ? 5 : 4))
score += i;
/* Check for hisnob */
for (i = 0 ; i < 4 ; ++i)
if (rank[i] == 11 && suit[i] == suit[4])
++score;
printf("%d\n", score ? score : 19);
return 0;
}
```
[Answer]
## Ruby 1.9, 359 356
It's far too long - almost as much as the C solution.
```
R='A23456789TJQK'
y=gets
f=y.scan /\w+/
o=f.map(&:chr).sort_by{|k|R.index k}
s=0
2.upto(5){|i|o.combination(i){|j|t=0
j.map{|k|t+=k==?A?1:k<?:?k.hex: 10}
(t==15||i<3&&j.uniq!)&&s+=2}}
m=n=l=1
(o+[z=?_]).map{|k|k[z]?n+=1:R[z+k]?(m*=n
l+=n=1):(l>2&&s+=l*m*n
l=n=m=1)
z=k}
x=f.take_while{|k|k[y[1]]}.size
x>(y[?!]?4:3)&&s+=x
y[?J+f[4][1]+' ']&&s+=1
p s>0?s:19
```
[Answer]
# Something to begin with.. Ruby, ~~422 365 355~~ 352
```
c=gets
a,b=c.scan(/(\w)(\w)/).transpose
f=->x{x.uniq.size<2}
s=f[b]?5:!c[/!/]&f[b[0,4]]?4:0
c[/J(.).*\1 ?!?$/]&&s+=1
s+=[5,4,3].map{|i|a.permutation(i).map{|x|'A23456789TJQK'[x*'']?i:0}.inject :+}.find{|x|x>0}||0
a.map{|x|s+=a.count(x)-1}
2.upto(5){|i|s+=2*a.map{|x|x.tr(?A,?1).sub(/\D/,'10').to_i}.combination(i).count{|x|x.inject(:+)==15}}
p s<1?19:s
```
Slightly ungolfed:
```
def t(c)
s=0
if c.scan(/[SDHC]/).uniq.size<2 # Flush
s+=5
elsif c[0..9].scan(/[SDHC]/).uniq.size<2 && c[-1]!=?! # Flush
s+=4
end
s+=1 if c =~ /J(.).*(\1$|\1\s.$)/ # Nobs
c=c.scan(/[^ \|]+/).map{|x|x[0]}[0..4]
d = (3..5).map{|i|c.permutation(i).map{|x| 'A23456789TJQK'.include?(x*'') ? i : 0}.inject(:+)}.reverse.find{|x|x>0} || 0# Runs
s+=d
c.map{|x|s+=c.count(x)-1} # Pairs
c.map!{|x|x.tr('A','1').gsub(/[JQK]/,'10').to_i}
(2..5).map{|i|s+=2*c.combination(i).count{|x|15==x.inject(:+)}} # 15s
s<1 ? 19 : s
end
```
Unit tests for golfed version:
```
require "test/unit"
def t(c)
c=gets
a,b=c.scan(/(\w)(\w)/).transpose
f=->x{x.uniq.size<2}
s=f[b]?5:!c[/!/]&f[b[0,4]]?4:0
c[/J(.).*\1 ?!?$/]&&s+=1
s+=[5,4,3].map{|i|a.permutation(i).map{|x|'A23456789TJQK'[x*'']?i:0}.inject :+}.find{|x|x>0}||0
a.map{|x|s+=a.count(x)-1}
2.upto(5){|i|s+=2*a.map{|x|x.tr(?A,?1).sub(/\D/,'10').to_i}.combination(i).count{|x|x.inject(:+)==15}}
p s<1?19:s
end
class Test1 < Test::Unit::TestCase
def test_simple
assert_equal 21, t("5S 5H 5D JS | KS")
assert_equal 21, t("JS 5H 5D 5S | KS")
assert_equal 12, t("JD 3C 4H 5H | 5S")
assert_equal 13, t("9S 8S 7S 6S | 5H")
assert_equal 14, t("8D 7D 6D 5D | 4D")
assert_equal 19, t("AD KD 3C QD | 6D")
assert_equal 9, t("AS 2D 3H JS | 4S !")
assert_equal 9, t("JS 2D 3H AS | 4S !")
assert_equal 14, t("8D 7D 6D 5D | 4D !")
assert_equal 9, t("9S 8S 7S 6S | 5H !")
end
end
```
Results:
```
% ruby ./crib.rb
Run options:
# Running tests:
21
21
12
13
14
19
9
9
14
9
.
Finished tests in 0.014529s, 68.8281 tests/s, 688.2813 assertions/s.
1 tests, 10 assertions, 0 failures, 0 errors, 0 skips
```
[Answer]
# Python, 629 characters
I'm only posting mine because no one else has. It's pretty long :(
```
g=range
i=raw_input().split()
r,u=zip(*[tuple(x)for x in i if x not in'!|'])
v=map(int,[((x,10)[x in'TJQK'],1)[x=='A']for x in r])
z=list(set(map(int,[(x,dict(zip('ATJQK',[1,10,11,12,13])).get(x))[x in'ATJQK']for x in r])))
z.sort()
z=[-1]*(5-len(z))+z
s=p=l=0
for a in g(5):
for b in g(a+1,5):
s+=2*(v[a]+v[b]==15)
p+=2*(r[a]==r[b])
if z[a:b+1]==g(z[a],z[b]+1)and b-a>1:l=max(l,b+1-a)
for c in g(b+1,5):s+=2*(v[a]+v[b]+v[c]==15)
for d in g(5):s+=2*(sum(v)-v[d]==15)
n=len(set(u))
s+=4*(n==2 and u[-1] not in u[:4] and i[-1]!='!')+5*(n<2)+('J'+u[4]in i[:4])+2*(sum(v)==15)+p+((l*3,l*p)[p<5]or l)
print(s,19)[s<1]
```
[Answer]
### GolfScript, 187 178 174 characters
```
:c"J"c{"SCDH"?)},1/:s-1=+/,([s)-!5*s);)-!4*c"!"?)!*]$-1=+0.14,{c{"A23456789TJQK"?)}%{},:v\{=}+,,.{@*\)}{;.2>**+1 0}if}/;;5-v{{=+}+v\/}/[0]v{.9>{;10}*{1$+}+%}/{15=},,2*+.!19*+
```
Since I never played cribbage I don't know any fancy scoring tricks. Therefore I thought the only way to compete (at least a little bit) is using a golf language. The code is pretty plain GolfScript, the test cases can be found [here](http://golfscript.apphb.com/?c=ewo6YyJKImN7IlNDREgiPyl9LDEvOnMtMT0rLywoW3MpLSE1KnMpOyktITQqYyIhIj8pISpdJC0xPSswLjE0LHtjeyJBMjM0NTY3ODlUSlFLIj8pfSV7fSw6dlx7PX0rLCwue0AqXCl9ezsuMj4qKisxIDB9aWZ9Lzs7NS12e3s9K30rdlwvfS9bMF12ey45Pns7MTB9KnsxJCt9KyV9L3sxNT19LCwyKisuITE5KisKfTpDT0RFOwoKOyI1UyA1SCA1RCBKUyB8IEtTIglDT0RFIHAJIyAyMQo7IkFTIDJEIDNIIEpTIHwgNFMgISIJQ09ERSBwCSMgOQo7IkpEIDNDIDRIIDVIIHwgNVMiCUNPREUgcAkjIDEyCjsiOVMgOFMgN1MgNlMgfCA1SCAhIglDT0RFIHAJIyA5CjsiOVMgOFMgN1MgNlMgfCA1SCIJQ09ERSBwCSMgMTMKOyI4RCA3RCA2RCA1RCB8IDREICEiCUNPREUgcAkjIDE0CjsiOEQgN0QgNkQgNUQgfCA0RCIJQ09ERSBwCSMgMTQKOyJBRCBLRCAzQyBRRCB8IDZEIglDT0RFIHAJIyAxOQo%3D).
The code in a more readable fashion (*reformatted and ungolfed a little*):
```
# Save cards to <c>
:c;
# Is it a non-crib hand? <r>
c"!"?)!:r;
# Values go to <v>
c{"A23456789TJQK"?)}%{},:v;
# Suits go to <s>
c{"SCDH"?)},1/:s;
# Print score for Fifteens
[0]v{.9>{;10}*{1$+}+%}/{15=},,2* .p
# Print score for Pairs
-5v{{=+}+v\/}/ .p
# Print score for Runs
0..14,{v\{=}+,,.{*\)\}{;\.2>**+0 1}if}/;; .p
# Print score for Flush
[s)-!5*s);)-!4*r*]$-1= .p
# And finally print the score for Nobs
c"J"s-1=+/,( .p
# Sum up the sub-scores and if score is zero set to 19
++++
.!19*+
```
*Edit:* Changed logic for fifteens and flushes.
[Answer]
# Python 2, ~~606~~ 584 bytes
Saved 22 bytes due to [Jo King](https://codegolf.stackexchange.com/users/76162/jo-king)'s golfing.
```
from itertools import*
s,S,C,E=sum,sorted,combinations,enumerate
def f(a):a=a.split();a.pop(4);e=a.pop(5)if a[-1]<"$"else 0;b=S("A23456789TJQK".index(i)for i,j in a);d=S(set(b));h=[j for i,j in a];z=len([s(k)for r in range(6)for k in C([[10,k+1][k<10]for k in b],r)if s(k)==15])*2+s(2for i,j in C(b,2)if i==j)+[4*(e<1),5][len(set(h))<2]*(len(set(h[:4]))<2)+(a[4][1]in[j for i,j in a[:4]if i=="J"])+s(reduce(lambda x,y:x*y,[b.count(k)for k in m])*len(m)for m in[d[s(x[:i]):s(x[:i])+j]for x in[[len(list(e))for i,e in groupby(j-i for i,j in E(d))]]for i,j in E(x)if j>2]);return z or 19
```
[Try it online!](https://tio.run/##fZLNbqMwFIX3eYpbNAs7caNAIX@EkapQKUpWFbOzvIDgNCZgkDESqfruGUw6UdLF7Ozz3eN7fO3qrI@ldC6XgyoLEJorXZZ5DaKoSqWHg5pEZE3egropSN0pPCX7skiEjLUoZU24bAquYs0HKT/AAcV4GQfxuK5yoRH243FVVsjFPg@uSw@LA8T02WYr65fF85rDxE@CCFmvzovrTWfzxZ/t@84aC5nyFgl8KBUIkoGQEGM/7SprrlGCsX8MaAb3mPmfQc4lojU69T5lZBXLD46mvXAywhpRak/IaWQzelrZE3YjCSPK5DP@ILA9hofOqEbOXZM1SohjakQQZHhE3SHiKxsTj1HT2mQ7Yrxy2BDd9nTpMqPhEYqpy6jNhPwR3ZRcD7W2FsNdU8XTZs9RHhdJGkNLzst2eCY0Ge/LRurvC/apiy6m6VX0UveIkqbdCFq6FAwv/y1GWX/P1uA@ai5qjTj@HjA3J32osqmSM8qexX26N5RizNiD0poZZL8dhn3FdaMkfELH7cWlUkLq7idYXgTeBrwQthF8wS6y8ODGXiNwQnjZXJkbwdM93XZoDe7G@L/Ae3AuIphHMItgapxdwdP/6D2bhzALYRqaSF3P8NH5kz6kDWHXR3o3bNqxy18 "Python 2 – Try It Online")
Slightly shorter than [grc](https://codegolf.stackexchange.com/a/5581/73368)'s answer, and takes a different route to get there.
## Explanation:
```
# import everything from "itertools" library. We only need "combinations" and "groupby".
from itertools import*
# alias functions to shorter names
s,S,C,E=sum,sorted,combinations,enumerate
# function f which takes the hand+up card+crib string as its argument
def f(a):
# convert space-separated string into list of items.
a=a.split()
# remove the 4th index, which is always "|".
a.pop(4)
# change golfed by Jo King
# if the final item in the list is a "!" (if it is <"$"), remove it from the list and assign it to variable "e".
# otherwise, assign 0 to variable "e".
# a non-empty string will evaluate to True and 0 will evaluate to False in IF checks later.
e=a.pop(5)if a[-1]<"$"else 0
# for each card in the list, split the identifiers into the value(i) and the suit(j).
# return the value's index in the string "A23456789TJQK".
# so, ["5S", "5H", "5D", "JS", "KS"] will return [4, 4, 4, 10, 12].
# using the aliased built-in function sorted(), sort the list numerically ascending.
b=S("A23456789TJQK".index(i)for i,j in a)
# get the unique items in b, then sort the result numerically ascending.
d=S(set(b))
# for each card in the list, split the identifiers into the value(i) and the suit(j).
# return the suits.
h=[j for i,j in a]
# fifteens
# changes golfed by Jo King
# generate pairs of (10, value + 1) for all cards (since they are zero-indexed)
# since True and False evaluate to 1 and 0 in python, return 10 if k>=10
# and reduce all values >10 to 10
# get all unique combinations of cards for 5 cards, 4 cards, 3 cards, 2 cards, and 1 card
# add the values of all unique combinations, and return any that equal 15
# multiply the number of returned 15s by 2 for score
z=len([s(k)for r in range(6)for k in C([[10,k+1][k<10]for k in b],r)if s(k)==15])*2
+
# pairs
# using itertools.combinations, get all unique combinations of cards into groups of 2.
# then, add 2 for each pair where both cards have an identical value.
s(2for i,j in C(b,2)if i==j)
+
# flush
# changes golfed by Jo King
# using list indexing
# [4 * (0 if crib else 1), 5], get item at index [0 if more than one suit in hand+up card else 1]
# -> 4 if not crib and not all suits same
# -> 5 if all cards same
# -> 0 otherwise
# * (0 if more than one suit in hand else 1)
# -> 4 * 0 if not crib and not all suits same
# -> 4 * 1 if not crib and all suits same
# -> 5 * 1 if all cards same
# -> 0 otherwise
[4*(e<1),5][len(set(h))<2]*(len(set(h[:4]))<2)
+
# nobs
# check if the suit of the 5th card (4, zero-indexed) matches the suit of any of the other 4 cards, and if it does is that card a Jack
(a[4][1]in[j for i,j in a[:4]if i=="J"])
+
# runs
s(reduce(lambda x,y:x*y,[b.count(k)for k in m])*len(m)for m in[d[s(x[:i]):s(x[:i])+j]for x in[[len(list(e))for i,e in groupby(j-i for i,j in E(d))]]for i,j in E(x)if j>2])
# since only 0 evaluates to false, iff z==0 return 19, else return z.
print z or 19
```
## Explanation for runs logic specifically:
```
# for each index and value in the list, add the value minus the index
# since the list is sorted and reduced to unique values, this means adjacent values will all be the same value after offset
# ex: "JD 3C 4H 5H | 5S" -> [2, 3, 4, 10] - > [2, 2, 2, 7]
z = []
for i,j in enumerate(d):
z.append(j-i)
# group the values by unique value
# then add the length of the groups to the list
# ex: [2, 2, 2, 7] -> [2:[2,2,2], 7:[7]]
# [2:[2,2,2], 7:[7]] -> [[3], [1]]
w = []
for i,e in groupby(z):
w.append([len(list(e))])
# list is double-nested so that the combined list comprehension leaves "x" available in both places it is needed
z = []
for x in w:
for i,j in enumerate(x):
if j>2:
# if the group length is larger than 2
# slice the list of unique card values to obtain only run values
# since the run can be anywhere in the list, sum the preceding lengths to find the start and end index
a = d[ sum(x[:i]) : sum(x[:i])+j ]
z.append(a)
w = []
for m in z:
# get the number of times the value is in the entire hand
# ex: "JD 3C 4H 5H | 5S" -> [2,3,4,4,10] and (2,3,4) -> [1, 1, 2]
a = [b.count(k)for k in m]
# multiply all values together
# [1, 1, 2] = 1*1*2 = 2
a = reduce(lambda x,y:x*y, a)
# length of the run * number of duplicate values
a *= len(m)
w.append(a)
# sum the results of the runs
return sum(w)
```
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 106 bytes
```
Çí╬Δ╓↔╥.L§º♦½┌§└─»◄G≤n▒HJ♀p$¼♥,Q¢▲»Δ÷♠º≈r↑Vo\b■┌4Üé∟]e:┬A½f║J4σ↔└ΓW6O?╧φ¡╫╠├√├ùß5₧k%5ê╜ò/Φ/7w╠█91I◘┬n≥ìk♂╪
```
[Run and debug online!](https://staxlang.xyz/#p=80a1ceffd61dd22e4c15a704abda15c0c4af1147f36eb1484a0c7024ac032c519b1eaffff606a7f77218566f5c62feda349a821c5d653ac241ab66ba4a34e51dc0e257364f3fcfedadd7ccc3fbc397e1359e6b253588bd952fe82f3777ccdb39314908c26ef28d6b0bd8&i=5S+5H+5D+JS+%7C+KS%0AAS+2D+3H+JS+%7C+4S+%21%0AJD+3C+4H+5H+%7C+5S%0A9S+8S+7S+6S+%7C+5H+%21%0A9S+8S+7S+6S+%7C+5H%0A8D+7D+6D+5D+%7C+4D+%21%0A8D+7D+6D+5D+%7C+4D%0AAD+KD+3C+QD+%7C+6D&a=1&m=2)
Bonus for CP437: See those suits symbol in the packed Stax? Too bad that the clubs do not appear ...
The ASCII equivalent is
```
jc%7<~6(4|@Y{h"A23456789TJQK"I^mXS{{A|mm|+15=_%2=_:u*+f%HxS{{o:-u1]=f{%mc3+|Msn#*+y{H"SHCD"ImY:uc5*s!yNd:u;**HH++yN|Ixs@11#+c19?
```
## Explanation
```
jc%7<~6(4|@Y...X...Y...c19?
j Split on space
c%7<~ Is it a crib hand? Put it on input stack for later use
6( Remove "!" if it exists
4|@ Remove "|"
Y Store list of cards in y
...X Store ranks in x
... Perform scoring for ranks
Y Store suits in y
... Perform scoring for suits
c19? If the score is 0, change it to 19
{h"..."I^mX
{ m Map each two character string to
h The first character
"..."I^ 1-based index of the character in the string
S{{A|mm|+15=_%2=_:u*+f%H
S Powerset
{ f%H Twice the number of elements that satisfy the predicate
{A|mm Value of card. Take the minimum of the rank and 10
|+15= Sum of values equal 15 (*)
_%2= Length is 2 (**)
_:u All elements are the same (***)
*+ ( (***) and (**) ) or (*)
xS{{o:-u1]=f{%mc3+|Msn#*+
xS Powerset of ranks
{ f Filter with predicate
{o Sort
:-u Unique differences between elements
1]= Is [1]
{%mc Length of all runs
3+|M Maximum of all the lengths and 3
sn# Number of runs with maximal length
* Multiplied by its length
+ Add to score
y{H"SHCD"ImY
y{ mY For each two character string
H"SHCD"I 0-based index of the second character in the string "SHCD"
:uc5*s!yNd:u;**HH++
:uc5* 5 points if all cards have same suit
s! Not all cards have same suit (#)
yNd:u First four cards have same suit (##)
; Not a crib hand (###)
**HH++ 4 points if (#) and (##) and (###), add to score
yN|Ixs@11#+
yN|I Index of cards with the same suit of last card (not including itself)
xs@ The rank at these indices
11# Number of Jacks with the same suit of last card
+ Add to score
```
] |
[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/102193/edit).
Closed 7 years ago.
[Improve this question](/posts/102193/edit)
[All-pairs shortest paths](https://en.wikipedia.org/wiki/Shortest_path_problem#All-pairs_shortest_paths) is a standard pathfinding problem. This is a twist on that.
# Definitions
We are searching for paths on a directed graph. Graphs are defined by square matrices, for example
```
0 3 2.5
1 0 1
0 -1 0
```
Write `M(r,c) = value in M at row r, column c` is the cost to travel from node `r` to node `c`. The graph is in general asymmetric, costs may be negative, and `M(i,i)=0` for all `i`. **An edge with cost zero does *not* exist**, i.e. treat zeros as infinities in the input.
Indexing from zero, the above graph can be visualised thus:
[](https://i.stack.imgur.com/oMJqQ.png)
# Goal
For a given valid, input matrix of any size output the matrix `MOUT(r,c)=cost of the shortest path from r to c and back to r`
The twist is: **you must make a return trip, without visiting any edges on the return trip which you used on the outward trip.** That is, `M(r,c)` and `M(c,r)` are considered to be *the same edge* albeit with a cost which depends on the direction of travel.
For example, the shortest path from `0 -> 1 -> 0` may not include both the edges `(0,1)` and `(1,0)`.
Nor may you re-use an edge in the outward trip.
Each return trip is considered independently of the others. If you use `(0,1)` in the path from `0 -> 1 -> 0` then you may use either `(0,1)` or `(1,0)` in the path from `0 -> 2 -> 0`.
# Input/Output Format
Input is on stdin and output on stdout.
The input and output is a matrix with columns separated by a number of spaces, and rows separated by a single `\n`.
Input entries are floating point numbers conforming to `/^-?[0-9]+(\.[0-9]*)?$/`. Output entries are numbers of the same kind or `Inf`, `Infinity`, or `NaN` or some equivalent symbol in the event that no return route exists between those nodes. A zero in the *input* matrix represents an infinite cost (non-existant edge) but zeroes in the *output* represent a cost-free journey.
Your program behaviour is undefined in the event that the input is not a finite real-valued square matrix.
# Requirements
Test against the following input matrices and post the results with your code.
A:
```
0 6 -5 -2 9
-3 0 0 -4 5
7 2 0 -8 1
-6 3 4 0 -9
8 -3 -1 2 0
```
B:
```
0 -0.3 2.4 -1
1 0 0.9 9.3
10 4 0 -2
8 -6 -7 0
```
C:
```
0 1 0 2
0 0 3 1
4 0 0 2
0 1 0 1
```
Shortest code wins.
]
|
[Question]
[
Here's an interesting challenge...
I want you to golf code that when executed will allow your input to be converted to mimic output as though you were typing on a DVORAK keyboard layout.
The aim is to mimic the US Simplified Dvorak Keyboard (US:SDK)
In comparison, here is the standard US QWERTY layout:
The keyboard emulation must work for both uppercase and lower case letters as well as shifted keys, for example, if I tapped the `q` (unshifted) key on my keyboard, the Dvorak code should pop out a `'` character on the screen. If I were to tap the `c` (unshifted) button I should get a `j` (also unshifted) in response, `C` (shifted) would get `J` (shifted) and so on...
I am only concentrating of course on the white keys in the diagram above. Tabs, Caps and the other grey keys should work as per normal...
Any questions? Not for now? Good...
I will not allow external resources that already have the layout encoded already, I will not have any files brought in that can encode the layout. The code MUST be `QWERTY INPUT -> (DVORAK RE-CODING) -> DVORAK OUTPUT` in nature. No silly Esolangs that are theoretical or just say something like "This program will take QWERTY input and recode it in DVORAK. This is the program." or crap like that... Take this challenge seriously... So Brainfuck coders, I welcome you.
Please note, this is NOT a string conversion program. For every QWERTY key you press, the corresponding DVORAK character must be outputted...
Shortest code wins...
[Answer]
# C - 144 characters
```
main(c){putch((c=getch())>33?c:"_#$%&-()*}w[vz0123456789SsW]VZ@AXJE>UIDCHTNMBRL\"POYGK<QF:/\\
=^{`axje.uidchtnmbrl'poygk,qf?|+~"[c-34]);main(0);}
```
[Answer]
### Shell: Unix [tr(1)](https://www.mirbsd.org/man1/tr), 94
```
tr \''"+-/:-[]_b-{}' "-_}w[vzSsW]VZ@AXJE>UIDCHTNMBRL\"POYGK<QF:/={xje.uidchtnmbrl'poygk,qf;?+"
```
This command takes QWERTY on stdin and outputs DVORAK on stdout.
[Answer]
## C#, 360 characters
Probably not the shortest, but it does exactly what you ask:
```
using System;class A{static void Main(){string[] q={"-=qwertyuiop[]sdfghjkl;'zxcvbnm,./","_+QWERTYUIOP{}SDFGHJKL:\"ZXCVBNM<>?","[]',.pyfgcrl/=oeuidhtns-;qjkxbmwvz","{}\"<>PYFGCRL?+OEUIDHTNS_:QJKXBMWVZ"};while(true){var c=Console.ReadKey(true);var a=c.KeyChar;int i,w=c.Modifiers==ConsoleModifiers.Shift?1:0;Console.Write((i=q[w].IndexOf(a))>-1?q[w+2][i]:a);}}}
```
If you press a key on your QWERTY keyboard, then the correct DVORAK character appears in the console.
[Answer]
# AutoHotKey, 200 bytes
```
-::[
=::]
q::'
w::,
e::.
r::p
t::y
y::f
u::g
i::c
o::r
p::l
[::/
]::=
s::o
d::e
f::u
g::i
h::d
j::h
k::t
l::n
`;::s
'::-
z::`;
x::q
c::j
v::k
b::x
n::b
,::w
.::v
/::z
```
There should be an answer in AHK for this question but not. So just post one.
[Answer]
# [R](https://www.r-project.org/), 157 bytes
Simple translate script.
```
chartr('\'qQwWeErRtTyYuUiIoOpP[{]}sSdDfFgGhHjJkKlL;:"zZxXcCvVbBnN,<.>/?=_+-','-\'",<.>pPyYfFgGcCrRlL/?=+oOeEuUiIdDhHtTnNsS_;:qQjJkKxXbBwWvVzZ{]}[',scan(,''))
```
[Try it online!](https://tio.run/##FY3HDoJAFEX3fAabpxF0jy0RsIcmKs0QhFEsoQyjIxq/fZTtPTnnYsbiNMIEtyCA0qR7pGKL2LX72F4WuV4Y/ufwrTaJcpqeZ@n8uryt7uu@xL@9lxPLz91xkmnCoDvqjYdhRwQBxAD4ZiiM2m2cWMbWff3HnVxHalNNlHRO7EyrNmFfKs0m@XKOE7p/7t7e/80HoYqjrCUAtNvMpAiTmiOoIhzNrYT9AA "R – Try It Online")
[Answer]
# [Python](https://www.python.org), 181 bytes
```
print(input().translate(str.maketrans("'qQwWeErRtTyYuUiIoOpP[{]}sSdDfFgGhHjJkKlL;:\"zZxXcCvVbBnN,<.>/?=_+-","-'\",<.>pPyYfFgGcCrRlL/?=+oOeEuUiIdDhHtTnNsS_;:qQjJkKxXbBwWvVzZ{]}[")))
```
This code takes QWERTY on stdin and outputs DVORAK on stdout.
It does this by creating a translation table from qwerty to dvorak then translates stdin with `input()` using that translation table
A cleaner representation
```
print(
input().translate(
str.maketrans(
"'qQwWeErRtTyYuUiIoOpP[{]}sSdDfFgGhHjJkKlL;:\"zZxXcCvVbBnN,<.>/?=_+-",
"-'\",<.>pPyYfFgGcCrRlL/?=+oOeEuUiIdDhHtTnNsS_;:qQjJkKxXbBwWvVzZ{]}[",
)
)
)
```
[Try it online!](https://tio.run/##HY7JDoIwAET/pRchIh684ZawuBJFQFYNQUFBsdRSZDF@O4rXN5k3gyoSpXDQNAjHkFAxRDmhaJZgH2aJT0IqI5h9@PfwTyjQee4KM5SwSvTKzvfxMt0ixX0fP5kWiJfZdR4tbqv7OpGH3AHUTmmdhZdx4uGGGbGT/nTsdXuAAb3OAbQAKZXdls4CVhP5F3fTbSi12kCMFkSHm0zzhtxz1zpL68QX5suond@cCxiappvmf/gL "Python 3 – 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/97538/edit).
Closed 7 years ago.
[Improve this question](/posts/97538/edit)
### N in a row
### Input:
The character and a 2-Dimensional array.
The array with a size of `N x N` where 1 <= `N` <= 26, it will be filled randomly like so:
`N` = 1
```
A
```
`N` = 2
```
B | A
-----
A | B
```
`N` = 3
```
A | B | C
----------
B | A | B
----------
C | A | C
```
As `N` increases by 1, so does the number of letters. A = 1, B = 2, C = 3. There will always be `N` number of each letter.
`N` = 3, there will be 3 As... 3 Bs... 3 Cs...
`N` = 4, there will be 4 As... 4 Bs... 4 Cs... 4 Ds...
`N` = 5, there will be 5 As... 5 Bs... 5 Cs... 5 Ds... 5 Es...
### Output:
The original matrix as well as a manipulated matrix where any given letter has `N` in a row (or column).
Manipulations occur by swapping two letters within the 2-D grid that are adjacent on the x or y axis. You may not swap characters over the boundaries of the array. I.E. You cannot swap Array[0][N-1] with Array[0][0]. You also may not swap characters diagonally.
### Objective:
Your job is to pick a character `C` to solve for given `N`. Swap characters within the matrix so that there are `N` of `C` in the same row or column.
### Examples:
`N` = 3, `C` = A
```
**A** | **B** | C
----------
B | A | B
----------
C | A | C
```
Swap array[0][0] (A) with array[1][0] (B)
resulting in
```
B | **A** | C
----------
B | **A** | B
----------
C | **A** | C
```
Complete
`N` = 4, `C` = B
```
A | **B** | C | D
--------------
B | **D** | B | A
--------------
D | A | C | C
--------------
A | C | B | D
```
swap array[1][0] (B) with array[1][1] (D)
```
A | D | C | D
--------------
B | B | B | A
--------------
D | A | C | C
--------------
A | C | **B** | **D**
```
swap array[2][3] (B) with array[3][3] (D)
```
A | D | C | D
--------------
B | B | B | A
--------------
D | A | C | **C**
--------------
A | C | D | **B**
```
swap array[3][3] (B) with array[3][2] (C)
```
A | D | C | D
--------------
B | B | B | **A**
--------------
D | A | C | **B**
--------------
A | C | D | C
```
swap array[3][2] (B) with array[3][1] (A)
```
A | D | C | D
--------------
**B** | **B** | **B** | **B**
--------------
D | A | C | A
--------------
A | C | D | C
```
Complete!
Any letter can be chosen to solve for. As this is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") the shortest code wins!
Have Fun and Good Luck!
[Answer]
# Python 2, 270 bytes
```
from random import*
e=lambda s,n:all(sum(map(ord,l))!=n*65for l in s)
R,C,d=randint,choice,[-1,1]
def w(a):
print a;n=len(a);
while e(a,n)and e(zip(*a),n):
if n==2:x,y,w,z=0,0,0,1
else:x,y=R(1,n-2),R(1,n-2);w,z=x+C(d),y+C(d)
a[y][x],a[z][w]=a[z][w],a[y][x]
print a
```
Always chooses `A` as character to complete a row/col. Performs random swaps until goal is reached.
Accepts the matrix as list of lists, usage for testing:
```
A="""ADCD
BBBA
DACC
ACDB"""
a=[[c for c in l] for l in A.split('\n')]
w(a)
```
[Answer]
# R, ~~41~~ 40 bytes
This answer provides valid output, although it does not follow the algorithm suggested. Since a limitless number of swapping manipulations are permitted, restrictions on what manipulations are allowed (e.g. the diagonal restriction) are irrelevant, as any permutation of the matrix can be arrived at through a (possibly large) number of swaps. So, I've bypassed the "switching around" part of the matrix manipulation and just went straight to outputting a solved matrix.
Anonymous function that takes a matrix as input, and returns a list of the original matrix and the "solved" matrix.
```
function(m)list(m,array(sort(m),dim(m)))
```
Example input:
```
matrix(c("A","B","A","C","C","B","A","C","B"),3)
```
That is,
>
> [,1] [,2] [,3]
>
>
> [1,] "A" "C" "A"
>
>
> [2,] "B" "C" "C"
>
>
> [3,] "A" "B" "B"
>
>
>
Gives the following output:
```
[[1]]
[,1] [,2] [,3]
[1,] "A" "C" "A"
[2,] "B" "C" "C"
[3,] "A" "B" "B"
[[2]]
[,1] [,2] [,3]
[1,] "A" "B" "C"
[2,] "A" "B" "C"
[3,] "A" "B" "C"
```
While we're at it, here's a function to generate possible input matrices:
```
make_matrix = function(N) matrix(sample(rep(LETTERS[1:N], N)), N)
```
This function takes the first `N` letters of the alphabet, repeated `N` times (i.e. `N*N` characters) and randomly samples from them. The characters are then arranged into a matrix with `N` rows (and, implicitly, `N` columns).
Examples:
```
make_matrix(1)
[,1]
[1,] "A"
> make_matrix(3)
[,1] [,2] [,3]
[1,] "C" "B" "C"
[2,] "C" "A" "B"
[3,] "A" "B" "A"
```
And used with our function above (named `f`):
```
> f(make_matrix(10))
[[1]]
[,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
[1,] "J" "C" "D" "G" "E" "C" "H" "G" "I" "J"
[2,] "C" "D" "A" "C" "H" "A" "A" "E" "H" "I"
[3,] "C" "B" "E" "G" "C" "F" "J" "A" "H" "J"
[4,] "I" "E" "F" "I" "B" "G" "E" "F" "F" "C"
[5,] "H" "I" "F" "D" "B" "G" "H" "A" "J" "H"
[6,] "J" "E" "D" "J" "A" "D" "B" "D" "G" "B"
[7,] "D" "B" "E" "A" "G" "H" "C" "C" "J" "B"
[8,] "H" "D" "I" "J" "B" "I" "I" "F" "E" "I"
[9,] "G" "F" "F" "A" "J" "E" "B" "A" "E" "D"
[10,] "H" "G" "A" "B" "D" "I" "C" "G" "F" "F"
[[2]]
[,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
[1,] "A" "B" "C" "D" "E" "F" "G" "H" "I" "J"
[2,] "A" "B" "C" "D" "E" "F" "G" "H" "I" "J"
[3,] "A" "B" "C" "D" "E" "F" "G" "H" "I" "J"
[4,] "A" "B" "C" "D" "E" "F" "G" "H" "I" "J"
[5,] "A" "B" "C" "D" "E" "F" "G" "H" "I" "J"
[6,] "A" "B" "C" "D" "E" "F" "G" "H" "I" "J"
[7,] "A" "B" "C" "D" "E" "F" "G" "H" "I" "J"
[8,] "A" "B" "C" "D" "E" "F" "G" "H" "I" "J"
[9,] "A" "B" "C" "D" "E" "F" "G" "H" "I" "J"
[10,] "A" "B" "C" "D" "E" "F" "G" "H" "I" "J"
```
] |
[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/95988/edit).
Closed 7 years ago.
[Improve this question](/posts/95988/edit)
**Challenge:** Write a piece of code that only runs when the code is not being altered. If you change anything, the code should detect this and deny running. Of course, it should not be possible to just alter the detection mechanism (since this is a change in itself).
]
|
[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 7 years ago.
[Improve this question](/posts/95216/edit)
In a smallish class, some lectures are set aside for working in groups. The instructors don't want people to group themselves together with the same people every time; instead, they create the groups beforehand, trying to make sure that all students work with one another as equally as possible. Your job is to write a program that makes student groups for one class, given all the groups in previous classes, in a way that minimizes the same people working together often.
## Format for groups for a single class
Students in the class will be numbered as consecutive integers, starting at 1 (or 0 if you prefer). The set of groups for a single class (hereafter called a "day of groups") will be a list of lists, or any reasonable alternative. **Every group must have size 3 or 4; and the number of 3-person groups must be as small as possible.** For example, in a 15-student class, the following is a valid day of groups:
```
{{1,8,10,15},{2,7,9},{3,6,12,13},{4,5,11,14}}
```
But five 3-student groups is invalid. Of course, no student can be in two different groups in a single day of groups.
## Input structure
The input will consist of one or more days of groups, each in the format described above; the days of groups can be separated from each other by commas, newlines, or anything reasonable. These represent the student groups that have already taken place in the past. **You may not assume that every student was present in every day of groups—students are sometimes absent!** For example, the following is a valid input (consisting of three days of groups) for a 13-person class:
```
{{1,2,3,4},{5,6,7},{8,9,10},{11,12,13}}
{{1,3,5,7},{9,11,13,2},{4,6,8,10}}
{{8,6,7,5},{3,10,9,13},{12,11,1}}
```
You may also include, if you wish, the number of students in the class (13 in this case) as an additional explicit input. Otherwise you may assume that the number of students equals the largest integer appearing in the input (assuming you 1-index as I am; for 0-indexed, the number of students equals 1 + the largest integer appearing in the input).
## Output structure
The output will be a single day of groups, representing the chosen group assignments for the next day of groups, containing all of the students in the class. You may write a program, function, snippet, or other useful code to accomplish this, and take input and generate output in any reasonable way. **The goal of the code is to generate a new day of groups with as small a "score" as possible, as described below.**
Given an input (representing the past days of groups), the "score" of a proposed output (representing the new day of groups) is calculated as follows:
* For every pair of students who are in the same group, count how many times they have been together in groups before; that number (0 or more) is added to the score.
* For every student in a 3-person group, count how many times they have been in a 3-person group in the past; that number (0 or more) is also added to the score.
For example, suppose the input for a 7-student class is given by
```
{{1,2,3,4},{5,6,7}}
{{1,3,5,7},{2,4,6}}
```
For the proposed output
```
{{1,6,7},{2,3,4,5}}
```
the score would be calculated as follows:
* 1 and 6 have never been in the same group before, so +0 to the score
* 1 and 7 have been in the same group once before, so +1 to the score
* 6 and 7 have been in the same group once before, so +1 to the score
* 2 and 3 have been in the same group once before, so +1 to the score
* 2 and 4 have been in the same group twice before, so +2 to the score
* 2 and 5 have never been in the same group before, so +0 to the score
* 3 and 4 have been in the same group once before, so +1 to the score
* 3 and 4 have been in the same group once before, so +1 to the score
* 4 and 5 have never been in the same group before, so +0 to the score
* 1 has never been in a 3-student group before, so +0 to the score
* 6 has been in a 3-student group twice before, so +2 to the score
* 7 has been in a 3-student group once before, so +1 to the score
Therefore the total score for that proposed day of groups is 10.
However, that proposed day of groups is not optimal—several possible days of groups have a score of 8, including:
```
{{1,2,5,6},{3,4,7}}
```
## Input/output size and runtime
You should assume that there are at least 6 students in the class, and you may assume that there are at most 30 students in the class. You may also assume that there will be at least 1 and at most 100 days of groups in the input.
## Evaluation criteria
This challenge is **popularity contest**. While I can't control the votes of the population, to me the ideal solution will contain:
* code that computes an output day of groups with the **minimal score possible given the input**, not just one with a "good" score;
* code that runs quickly (for example, in 10 seconds or less on a class of size 20);
* a justification for why the code produces the minimal possible score;
* a link to an online implementation of the code.
## Example inputs and outputs
Input #1:
```
{{1,2,3,4},{5,6,7,8},{9,10,11,12}}
```
Output #1: there are many configurations with a score of 3, one of which is:
```
{{1,2,5,9},{3,6,7,10},{4,8,11,12}}
```
Input #2:
```
{{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15}}
{{1,5,9,13},{2,6,10,14},{3,7,11,15},{4,8,12}}
{{1,8,10,15},{2,7,9},{3,6,12,13},{4,5,11,14}}
{{1,7,12,14},{2,8,11,13},{3,5,10},{4,6,9,15}}
```
Output #2, with a score of 0, is unique in this case (up to reordering within each list):
```
{{1,6,11},{2,5,12,15},{3,8,9,14},{4,7,10,13}}
```
Input #3:
```
{{1,2,3},{4,5,6},{7,8,9}}
{{1,2,4},{3,5,8},{6,7,9}}
{{1,5,6},{2,3,9},{4,7,8}}
{{1,6,8},{2,4,9},{3,5,7}}
{{1,3,7},{2,6,8},{4,5,9}}
{{1,8,9},{2,5,7},{3,4,6}}
{{1,4,7},{2,5,8},{3,6,9}}
```
Output #3, with a score of 72, is also unique (up to reordering):
```
{{1,5,9},{2,6,7},{3,4,8}}
```
]
|
[Question]
[
Given an unsorted list of unique, positive integers, output the shortest list of the longest possible ranges of sequential integers.
# INPUT
* An unsorted list of unique, positive integers
+ e.g. `9 13 3 11 8 4 10 15`
* Input can be taken from any one of the following:
+ `stdin`
+ command-line arguments
+ function arguments
# OUTPUT
* An ordered list of ranges or individual values printed on one line to stdout or your language's closest similar output.
+ If two or more sequential integers (sequential by value, not by location in the list) are present, they will be denoted as an inclusive range using -, e.g. `8-11`
+ All other integers are simply printed with no other notation
+ A single space will delimit the output
* Numbers not present in the input should not be in the output, e.g. `3 5 6` cannot be shortened to `3-6` because `4` is not present
# EXAMPLES
**Successful:**
```
IN> 9 13 3 11 8 4 10 15 6
OUT> 3-4 6 8-11 13 15
IN> 11 10 6 9 13 8 3 4 15
OUT> 3-4 6 8-11 13 15
IN> 5 8 3 2 6 4 7 1
OUT> 1-8
IN> 5 3 7 1 9
OUT> 1 3 5 7 9
```
**Wrong:**
```
IN> 9 13 3 11 8 4 10 15
OUT> 3-15
```
Range contains values not in the input
```
IN> 9 13 3 11 8 4 10 15
OUT> 3 4 8 9 10 11 13 15
```
All sequential values should be represented as a range
```
IN> 9 13 3 11 8 4 10 15
OUT> 3-4 8-9 10-11 13 15
```
Divided range, `8-9` and `10-11` should be `8-11`
```
IN> 9 13 3 11 8 4 10 15
OUT> 8-9 13 10-11 3-4 15
```
Output not ordered correctly
# RULES
* [Standard loopholes are disallowed](http://meta.codegolf.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default)
* If your language has a function to do this it's not allowed
* You may write a full program, or a function
* trailing whitespace doesn't matter
# SCORING
* Least bytes wins
[Answer]
# Python 2, ~~123~~ 120 bytes
```
N=sorted(map(int,raw_input().split(' ')));print(''.join((''if n+1in N else'-'+`n`)if n-1in N else' '+`n`for n in N)[1:])
```
If the input can be a list as a function argument then (thanks mbomb007 and xnor for the conditionals)
# ~~93~~ ~~90~~ 81 bytes
```
def f(N):print''.join((' '+`n`,`-n`*-~-(n+1in N))[n-1in N]for n in sorted(N))[1:]
```
(77 bytes if leading whitespace is acceptable - drop the final `[1:]`)
[Answer]
# JavaScript (ES6): ~~171~~ ~~154~~ 140 ~~137~~ bytes
Thanks edc65 and vihan1086 for the tips! ~~`[...n]` is very nice~~ but it doesn't work in these cases due to multi-digit numbers.
```
f=n=>{s=e=o='';n.split` `.map(Number).sort((a,b)=>a-b).map(v=>{s=s||v;if(e&&v>e+1){o+=`${s<e?s+'-'+e:s} `;s=v}e=v});return o+(s<e?s+'-'+e:e)}
```
## ES5 variant, ~~198~~ ~~184~~ ~~183~~ 174 bytes
```
f=function(n){s=e=o='';n.split(' ').map(Number).sort(function(a,b){return a-b}).map(function(v){s=s||v;if(e&&v>e+1){o+=(s<e?s+'-'+e:s)+' ';s=v}e=v});return o+(s<e?s+'-'+e:e)}
```
```
f = function (n) {
s = e = 0, o = '';
n.split(' ').map(Number).sort(function (a, b) {
return a - b
}).map(function (v) {
s = s || v;
if (e && v > e + 1) {
o += (s < e ? s + '-' + e : s) + ' ';
s = v
}
e = v
});
return o + (s < e ? s + '-' + e : e)
}
// Demonstration
document.body.innerHTML = f('1 2');
document.body.innerHTML += '<p>' + f('9 13 3 11 8 4 10 15 6');
document.body.innerHTML += '<p>' + f('11 10 6 9 13 8 3 4 15');
document.body.innerHTML += '<p>' + f('5 8 3 2 6 4 7 1');
document.body.innerHTML += '<p>' + f('5 3 7 1 9');
```
[Answer]
# Ruby, 70 bytes
Problems like these tend to make me check the Ruby API for suitable methods, and today I discovered a new one: [`Array#slice_when`](http://ruby-doc.org/core-2.2.2/Enumerable.html#method-i-slice_when), newly introduced in Ruby v2.2 and seemingly intended for this exact situation :)
```
f=->a{puts a.sort.slice_when{|i,j|j-i>1}.map{|x|x.minmax.uniq*?-}*' '}
```
After sorting and appropriately slicing the array, it takes each sub-array and creates a string out of the highest and lowest element, and then joins this whole array into a string.
Example:
`f.call [9,13,3,11,8,4,10,15,6]` prints `3-4 6 8-11 13 15`
[Answer]
# SWI-Prolog, ~~165~~ ~~162~~ 159 bytes
```
b(Z,C,[D|E]):-Z=[A|B],(A=:=D+1,(B=[],put(45),print(A);b(B,C,[A,D|E]));(E=[],tab(1),print(A);writef('-%t %t',[D,A])),b(B,A,[A]));!.
a(A):-sort(A,B),b(B,_,[-1]).
```
Pretty bad but then again Prolog is a terrible golfing language
Example: `a([9,13,3,11,8,4,10,15,6]).` outputs `3-4 6 8-11 13 15`
[Answer]
# Ruby, ~~86~~ 84 bytes
```
s=->*a{puts a.sort.slice_when{|i,j|i+1!=j}.map{|e|e.size<2?e:[e[0],e[-1]]*"-"}*" "}
# demo
s[9, 13, 3, 11, 8, 4, 10, 15, 6]
# => 3-4 6 8-11 13 15
```
This is a slightly golfed version from an example in the docs for [slice\_when](http://ruby-doc.org/core-2.2.2/Enumerable.html#method-i-slice_when).
[Answer]
# CJam, 35 bytes
```
l~${__0=f-ee::=0+0#/((oW>Wf*S+oe_}h
```
Try it online in the [CJam interpreter](http://cjam.aditsu.net/#code=l~%24%7B__0%3Df-ee%3A%3A%3D0%2B0%23%2F((oW%3EWf*S%2Boe_%7Dh&input=%5B9%2013%203%2011%208%204%2010%2015%206%5D).
### How it works
```
l~$ e# Read a line from STDIN, evaluate it and sort the result.
{ e# Do:
_ e# Push a copy of the array.
_0=f- e# Subtract the first element from all array elements.
ee e# Enumerate the differences: [0 1 4] -> [[0 0] [1 1] [2 4]]
::= e# Vectorized quality: [i j] -> (i == j)
0+ e# Append a zero.
0# e# Push the first index of 0.
/ e# Split the array into chunks of that size.
( e# Shift out the first chunk.
(o e# Print its first element.
W> e# Discard all remaining elements (if any) except the last.
Wf* e# Multiply all elements of the remainder by -1.
S+o e# Append a space and print.
e_ e# Flatten the rest of the array.
}h e# Repeat while the array is non-empty.
```
[Answer]
# CJam, ~~38~~ 33 bytes
New version, using ideas and code fragments suggested by @Dennis:
```
l~$_,,.-e`{~T+\_T+:T;(_2$+W*Q?S}/
```
[Try it online](http://cjam.aditsu.net/#code=l~%24_%2C%2C.-e%60%7B~T%2B%5C_T%2B%3AT%3B(_2%24%2BW*Q%3FS%7D%2F&input=%5B9%2013%203%2011%208%204%2010%2015%5D)
The input format is a CJam array in square brackets.
The basic idea here is that I subtract a monotonic sequence from the sorted input sequence first:
```
3 4 8 9 10 11 13 15
0 1 2 3 4 5 6 7 (-)
----------------------
3 3 6 6 6 6 7 8
```
In this difference, values that are part of the same interval have the same value. Applying the CJam RLE operator to this difference directly enumerates the intervals.
The subtracted sequential values need to be added back during output. I'm not entirely happy with how that's done in my code. I suspect that I could save a few bytes with a more elegant way of handing that.
For generating the output of the intervals, this uses Dennis' idea of generating a negative number for the end value, which takes care of producing a `-`, and also simplifies the logic because only one value needs to be added/omitted depending on the interval size.
Explanation:
```
l~ Get input.
$ Sort it.
_,, Create monotonic sequence of same length.
.- Calculate vector difference between the two.
e` Calculate RLE of difference vector.
{ Loop over entries in RLE.
~ Unpack the RLE entry, now have length/value on stack.
T+ Add position to get original value for start of interval.
\ Bring length of interval to top of stack.
_T+:T; Add length of interval to variable T, which tracks position.
( Decrement interval length.
_ Copy it, we need it once for calculating end value, once for ternary if condition.
2$ Copy interval start value to top...
+ ... and add interval length - 1 to get end value.
W* Negate end value.
Q? Output end value if interval length was > 1, empty string otherwise.
S Add a space.
}% End loop.
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 16 bytes
```
ṢI’kƊ.ịⱮUQ€j€”-K
```
[Try it online!](https://tio.run/##y0rNyan8///hzkWejxpmZh/r0nu4u/vRxnWhgY@a1mQB8aOGubre/w@3A5mR//9HW@ooGBrrKACRoaGOgoWOggmQZQDEpjoKZrE6CtEgYZCAmY4CVK0FWDlInSlIgSlMxAisCChuDpSCyhhDeEC9sQA "Jelly – Try It Online")
## How it works
```
ṢI’kƊ.ịⱮUQ€j€”-K - Main link. Takes an array L on the left
Ṣ - Sort L; Call this A
Ɗ - Monad. Link the previous three links together f(A):
I - Forward differences
’ - Decrement
k - Partition
This groups consecutive runs
Take A = [3, 4, 6, 8, 9, 10, 11, 13, 15]
I: [1, 2, 2, 1, 1, 1, 2, 2]
’: [0, 1, 1, 0, 0, 0, 1, 1]
k then partitions A at truthy elements in I’
[[3, 4], [6], [8, 9, 10, 11], [13], [15]
Ɱ - For each:
.ị - Take the 0.5th element
For non-integer left argument, x, Jelly's ị atom takes
floor(x) and ceil(x) and returns [floor(x)ịy, ceil(x)ịy]
As Jelly's indexing is 1-based and modular:
0ị returns the last element
1ị returns the first element
.ị returns [0ị, 1ị]
U - Reverse each
Q€ - Deduplicate each
j€”- - Join each with "-"
K - Join by spaces
```
[Answer]
# [Husk](https://github.com/barbuz/Husk), ~~21~~ 20 bytes
```
;moJ'-?I§e←→ε†sġ·=←O
```
[Try it online!](https://tio.run/##yygtzv7/3zo330td197z0PLUR20THrVNOrf1UcOC4iMLD223BQr4////P9pSx9BYx1jH0FDHQsdEx9BAx9BUxywWAA "Husk – Try It Online")
A bit lacking in the strings department, but does well.
No matter what I tried, it somehow stubbornly stayed at 21.
-1 byte from Dominic Van Essen.
## Explanation
```
;moJ'-?I§e←→ε†sġ§=…eO
O order the list
ġ group the list by the following:
e elements paired
§= equal
… the range between them?
†s convert all the numbers to strings
mo map each group to the following:
? ε if it's a single element:
I leave as is
§e←→ otherwise, move the first and last elements to a list
J'- join with '-'
; nest to display in one line
```
[Answer]
## CoffeeScript, ~~178~~ 161 bytes
Just like my JavaScript answer. I need to figure out if using comprehensions will result in shorter code.
```
f=(n)->s=e=o='';n.split(' ').map(Number).sort((a,b)->a-b).map((v)->s=s||v;(o+=s+(if s<e then'-'+e else'')+' ';s=v)if(e&&v>e+1);e=v);o+(if s<e then s+'-'else'')+e
```
---
Original:
```
f=(n)->o='';s=e=0;n.split(' ').map(Number).sort((a,b)->a-b).forEach((v,i)->if!i then s=v else(o+=s+(if s<e then'-'+e else'')+' ';s=v)if(v!=e+1);e=v);o+(if s<e then s+'-'else'')+e
```
[Answer]
# Python 2, ~~126~~ ~~122~~ 121 Bytes
I know this can get shorter, just don't know where.. Requires input in form `[#, #, #, #, ..., #]`.
```
l=sorted(input());s=`l[0]`;c=0;x=1
while x<len(l):y,z=l[x],l[x-1];s+=(('-'+`z`)*c+' '+`y`)*(y-z>1);c=(y-z<2);x+=1
print s
```
[Answer]
# Java, 191 bytes
```
void f(int[]a){java.util.Arrays.sort(a);for(int b=a.length,c=b-1,i=0,j=a[0],l=j;++i<b;){if(a[i]!=++j||i==c){System.out.print((l+1==j?l+(i==c?" "+a[c]:""):l+"-"+(i==c?j:j-1))+" ");l=j=a[i];}}}
```
Checks for ranges and prints them accordingly. Unfortunately I had to make a special case for the last element in the array since the program would terminate without printing the last number or range.
[Answer]
# Java, ~~171~~ 162 bytes
```
String s(int[] n){Arrays.sort(n);int p=0,b=0;String r="",d="";for(int c:n){if(c==++p)b=1;else{if(b==1){r+="-"+--p+d+c;p=c;b=0;}else{r+=d+c;p=c;}d=" ";}}return r;}
```
Takes input as an int array, returns output as a space-separated String list
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-S`](https://codegolf.meta.stackexchange.com/a/14339/), ~~17~~ 16 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
ÍòÈnYÉÃ®é ¯2 Ôq-
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LVM&code=zfLIblnJw67pIK8yINRxLQ&input=WzkgMTMgMyAxMSA4IDQgMTAgMTUgNl0)
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `S`, 120 [bitsv1](https://github.com/Vyxal/Vyncode/blob/main/README.md), 15 bytes
```
s:¯Ǐ⁽ṅḋ•ꜝƛ₍htU\-j
```
[Try it Online!](https://vyxal.pythonanywhere.com/?v=1#WyJTfj0iLCIiLCJzOsKvx4/igb3huYXhuIvigKLqnJ3Gm+KCjWh0VVxcLWoiLCIiLCIhKC4qKSAtPiBcIiguKilcIlxuWzYsIDEsIDIsIDQsIDMsIDUsIDgsIDcsIDEwXSAtPiBcIjEtOCAxMFwiXG5bMTEsIDEwLCA2LCA5LCAxMywgOCwgMywgNCwgMTVdIC0+IFwiMy00IDYgOC0xMSAxMyAxNVwiXG5bOSwgMTMsIDMsIDExLCA4LCA0LCAxMCwgMTUsIDZdIC0+IFwiMy00IDYgOC0xMSAxMyAxNVwiXG5bNSwgOCwgMywgMiwgNiwgNCwgNywgMV0gLT4gXCIxLThcIlxuWzUsIDMsIDcsIDEsIDldIC0+IFwiMSAzIDUgNyA5XCIiXQ==)
## Explained
```
s:¯Ǐ⁽ṅḋ•ꜝƛ₍htU\-j
s: # Push two copies of the input list but sorted
¯Ǐ # Forward differences of items with the first item appended - this is for making sure the length of the deltas matches the length of the input
⁽ṅḋ # Grouped by whether they are <= 1
• # Reshape the sorted input to that shape
ꜝ # and remove the 0
# the top of the stack will be a list of lists of numbers that are ranges
ƛ # to each range
₍htU # either get the first and last item or just the first
\-j # join on "-"
# S flag joins the result on spaces
```
[Answer]
# [Haskell](https://www.haskell.org/), 187 bytes
```
import Data.List
g p[x]=[[x]]
g p(a:b:c)|let(d:e)=g p(b:c)=if p a b then(a:d):e else[a]:(d:e)
p[x]=show x++" "
p x=show(head x)++"-"++show(last x)++" "
f=concatMap p.g(((-1==).).(-)).sort
```
[Try it online!](https://tio.run/##JY7LCoMwFET3fsVFukgwhoY@aAPZddl@gbi41WhCo4YmUBf9dxvtZmAOh2EMhpd2blns4Kd3hBtG5HcbYtaDr@ZaVSnqtRCUT9nQr9ORtFJTtbKVKNuBB4QnRKPHpLVUatAu6AprubnZNhXM9IG5KHLIMw/z1onR2MJMEy3zotiQwxD/KImdaqaxwfhAD573hJBSKEU55aSklId0ehnQjsq/7Rh33a66MnFgByYEu7AjE3smTuxcLz8 "Haskell – Try It Online")
[Answer]
# [Scala](https://www.scala-lang.org/), 204 bytes
Modified from [@steenslag's Ruby answer](https://codegolf.stackexchange.com/a/52328/110802).
---
Golfed version. [Try it online!](https://tio.run/##PU9NT8QgEL3vr5g0HhiLuF0/oigmHj142nja9ICU3aC0W4GYaMNvr1OMkpkwvOG9mReN9no@vr5Zk@BZuwGmubN7iEzLpyGdotzaj902BTccWjV9ag9RaRGPIdnujpUmJX1t2@XFIlsj4rmMInrXEYttECdm@Ijqwe3ZSP26UWpkDaIRbnBJ1swIryMVBbU@WjCyXuQKkEWvRxYKP4jovu39BoPo33/3gkKI1ckUSDyf0V3kcoV5Bljs9OSM6XCIEh5D0F9/jlDCC20ACqYV0BkJTX4gF7ccmgsOFE3D4YbDJVVryisO1/g/m1VQIRI3r/L8Aw)
```
def s(a:Int*):Seq[String]={val s=a.sorted;(Seq[Seq[Int]](Seq(s(0)))/:s.sliding(2)){(c,p)=>if(p(0)+1==p(1))c.init:+(c.last:+p(1))else c:+Seq(p(1))}.map(r=>if(r.size<2)r.mkString else s"${r(0)}-${r.last}")}
```
Ungolfed version. [Try it online!](https://tio.run/##XVHRSsMwFH3fVxyKD4mrYZ1TtFjBR2G@KD6NPVzbdEaztiRB0NFvr2myDTZIQs49595zL9eWpGkY2o8vWTq8kGqwmwCVrGEZ5Xhu3CXP8d4ohyJQwA9p2NY4WfkQifg9Y16p2Ujr@QiF1apSzYbNuahbXS1l7dhSWbcKj3dZrwNme/2npIpzjh0YlWWKjpThKB6DDaBqsDHEZhxTZCiKoGCZT/F6ocZ@82lIFppsAAfFvobUVo7ikQrWJ3x/HMicjhInE1vqWGB8U6GdAIRVfxIPmPOYJrbfb874waObTS52MT7O118d0Nhhn0TjzsudbmI9eyzAEiShtX6y38/WL4uR2dgcT8bQ7yoK1@frsuw@RXadwp8sS3GXYuF/M39vUtzGmv1kGP4B)
```
object Main {
def s(a: Int*): Unit = {
val sorted = a.sorted
val sortedRanges = sorted.sliding(2).foldLeft(List[List[Int]](List(sorted.head))) { (acc, pair) =>
if (pair(0) + 1 == pair(1)) acc.init :+ (acc.last :+ pair(1))
else acc :+ List(pair(1))
}
val ranges = sortedRanges.map(range => if (range.size < 2) range.mkString else s"${range.head}-${range.last}")
println(ranges.mkString(" "))
}
def main(args: Array[String]): Unit = {
s(9, 13, 3, 11, 8, 4, 10, 15, 6)
}
}
```
[Answer]
# [Ly](https://github.com/LyricLy/Ly), 35 bytes
```
a0r[r0Ir::u[ps`=]pl~!['-olu!]p' o];
```
[Try it online!](https://tio.run/##y6n8/z/RoCi6yMCzyMqqNLqgOME2tiCnTjFaXTc/p1QxtkBdIT/W@v9/Q0MuQwMuMy5LLkNjLgsuYy4TLkNTAA "Ly – Try It Online")
This is pretty brute force. It sorts the numbers then iterates until all the numbers have been consumed. After printing the "current" number on the stack, an inner loop consumes all the entries after that which are consequitive. Then it either appends a `-#` string or not before printing a space and iterating again.
```
# prep work... created sorted list of numbers with trailing "0"
a0r
a - read numbers from STDIN, sort stack
0 - push a "0"
r - reverse stack
# loop over all numbers, then exit
[ ];
[ ] - iterate while top of stack not "0"
; - exit to avoid dumping junk on stack
# remember the current number for comparison later
r0Ir
r - reverse stack
0I - copy bottom of stack entry to the top
r - reverse the stack
# print the current number, loop/consume all sequential nums on stack
::u[ps`=]p
:: - duplicate top of stack twice
u - print current number
[ ]p - loop until top of stack is "0"
p - delete previous number
s - save the current number
`= - increment current number, compare to next num on stack
# print "-X" if needed to cover delete numbers, then print space
l~!['-olu!]p' o
l - load saved num (last number deleted)
~ - search stack for that number
! - negate result
[ ]p - "then" code block
'-o - print "-"
lu - load last num in sequence (last deleted)
! - flip top of stack to "0" to exit loop
' o - print " "
```
[Answer]
# [Perl 5](https://www.perl.org/) `-pa`, 95 bytes
```
$_=join$",sort{$a-$b}@F;$b=$_,s/(\d+)\K (?=(\d+))/$2-$1-1?$":"-"/ge while$_ ne$b;s/(-\d+)+/$1/g
```
[Try it online!](https://tio.run/##HcvNCoJAFIbhW/kYzkLR08yxLErEVm2iOxBEaTBDHFGhRXTrTT@7d/G8o5361Huq8rvrBlLx7KblSTVT8zqeMmpyquJZB@U1CsszgiL/Z6gpYRKWgtRBsdKtxePW9ZYqDJaa7LvwD0aaRLfeb5Biiz0EO4iBCCRBYrB@u3Hp3DB7vqQrI8ZzPX4A "Perl 5 – Try It Online")
] |
[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/89756/edit).
Closed 7 years ago.
[Improve this question](/posts/89756/edit)
Your task is to, given an image, compress it to 100000 bytes or less, while following all of the below rules:
* No cheating/loopholes.
* Your code must not be optimized to work best only on the test set of images, but rather produce a good output in general.
* Colours that do not exist in the original input image must also not exist in the output image. You do not necessarily have to use *all* of the colours in the input image, so you may use a subset of them if you want to, but, there must not be any extra colours in the output image that were not present in the input image.
* The input will be at minimum of image types/file extensions *JPG*, *PNG*, *GIF* (including animated GIFs), and *BMP.* Your code may support any additional formats for input and output beyond the minimum described above, if you want to.
* The output image must remain in the same file format/extension as the original image, unless your code doesn't support a format and you'd need to convert it. Conversion processing must be done losslessly and outputted to a lossless file format. Therefore, there must not be anything added or removed at all from the image during the format conversion process.
* The maximum filesize of the output image after compression is exactly 100000 bytes.
* You must *not* losslessly compress images. Theoretically speaking, "[any lossless compression algorithm that makes some files shorter must necessarily make some files longer.](https://en.wikipedia.org/wiki/Lossless_compression#Limitations)"
* The output image must have the exact same dimensions/size as the input image.
* Theoretically speaking, every possible input your algorithm/code gets *must* produce an output of 1000000 bytes or less.
Your code must produce good output on most images in general, but, for this challenge, you must test your code on [this test set of images](https://i.stack.imgur.com/lOaVI.jpg) and upload your output.
You must also show the code that you used, and not just the output images.
Your score is determined by the sum the squared difference between the input and output images.
As an example:
If the first pixel in the uncompressed image is RGB (2,3,4) and the first pixel in the compressed image is RGB (5,6,7), then the squared distance for that pixel is (2-5)^2+(3-6)^2+(4-7)^2, and then you sum that up for all the pixels.
Thank you, and good luck!
]
|
[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/89126/edit).
Closed 7 years ago.
[Improve this question](/posts/89126/edit)
**The Challenge**
Given an algebraic expression (eg `2ab`, change it so it follows standard convention rules.
**The Rules**
* Letters should be in alphabetical order. ie `2ab` is allowed but not `2ba`.
* Numbers should always go first. ie `2ab` is allowed but `ab2` is not.
* Exponentiation will be given as `a^b` to mean `a` to the power of `b`.
* These rules must be applied to every sub-expression. ie `2ab + ba3` becomes `2ab + 3ab`, `2vd * vd5` becomes `2dv * 5dv`. **This must work for at least addition, subtraction, multiplication, division, modulus and exponentiation.**
* Exponentiation is assumed to belong to the variable immediately preceding it and must stay with the variable it is assigned to. ie `2ba^2` becomes `2a^2b`. This means that all variables to the right of `^` are part of the exponentiation.
**Sample Input/Output**
Input can be given with any amount of white space, which must be ignored. Output can use either one space or none. For example, `2ab +3ba` could become `2ab + 3ab` or `2ab+3ab`
```
Input -> Output
2ba -> 2ab
4gb + 5vh * gh7 -> 4bg + 5hv * 7gh
2ba^2 -> 2a^2b
5xk^2ba -> 5k^2abx
```
(The last couple of outputs don't make sense mathematically because of order of operations, but you don't have to worry about that.)
**Scoring**
Standard code golf, shortest answer in bytes wins. Answer can be a program which takes input, or a function (can be anonymous).
[Answer]
# Ruby, 112 + 1 (`p` flag) = 113 bytes
Run as `ruby -pe` with the code surrounded by single quotes. Full program, even if it looks like just a recursive function at the beginning.
```
f=->s{s.scan(/(\w)(\^.+)?/).map{|a,b|[a,b&&?^,b&&f[b]]}.sort_by &:first};gsub(/[\w^]+/){f[$&]*""};gsub(/\s+/,"")
```
] |
[Question]
[
Objectives: Output a String which contains every positive integer strictly below 1000.
The obvious answer would be to concatenate every one of them, and that would create a String of 2890 characters (thanks manatwork), to avoid this kind of easy answer, the length of the string must be under 1500 characters.
Here is a straightforward Java code which outputs a 1200 chars String.
```
import org.junit.Test;
import java.util.ArrayList;
import java.util.List;
import java.util.TreeSet;
import static org.junit.Assert.assertTrue;
/**
* Created with IntelliJ IDEA.
* User: fab
* Date: 05/11/13
* Time: 09:53
* To change this template use File | Settings | File Templates.
*/
public class AStringToContainThemAll {
@Test
public void testsubStrings() throws Exception {
String a = generateNewString();
boolean cool = true;
for (int i = 0; i < 1000; i++) {
assertTrue(a.contains(Integer.toString(i)));
}
}
private String generateNewString() {
List<Integer> myTree = new ArrayList<Integer>();
String finalString = new String("100");
for (int i = 10; i < 1000; i++) {
myTree.add(i);
}
while (myTree.size() > 0) {
if (finalString.contains(Integer.toString(myTree.get(0)))) {
myTree.remove(0);
} else {
String substringLong = finalString.substring(finalString.length() - 2, finalString.length());
boolean found = false;
loop:
for (Integer integer : myTree) {
if (integer.toString().startsWith(substringLong) && !finalString.contains(integer.toString())) {
finalString = finalString.concat(integer.toString().substring(2, 3));
myTree.remove(integer);
found = true;
break loop;
}
}
if(! found){
finalString = finalString.concat(myTree.get(0).toString());
myTree.remove(0);
}
}
}
return finalString;
}
}
```
Shortest code win, bonus point for the shortest String!
[Answer]
## GolfScript (35 31 26 chars)
```
10,{:x),{:&x=x+,{x&@}/}/}/
```
Output is
```
000100110111200201210211220221222300301302310311312320321322330331332333400401402403410411412413420421422423430431432433440441442443444500501502503504510511512513514520521522523524530531532533534540541542543544550551552553554555600601602603604605610611612613614615620621622623624625630631632633634635640641642643644645650651652653654655660661662663664665666700701702703704705706710711712713714715716720721722723724725726730731732733734735736740741742743744745746750751752753754755756760761762763764765766770771772773774775776777800801802803804805806807810811812813814815816817820821822823824825826827830831832833834835836837840841842843844845846847850851852853854855856857860861862863864865866867870871872873874875876877880881882883884885886887888900901902903904905906907908910911912913914915916917918920921922923924925926927928930931932933934935936937938940941942943944945946947948950951952953954955956957958960961962963964965966967968970971972973974975976977978980981982983984985986987988990991992993994995996997998999
```
(1020 chars) This is a variant on the Lyndon word concatenation approach: rather than use the primitive 1-char words it uses multiples of 111 for shorter code but repeated occurrences of those numbers; and rather than use minimal elements of the conjugacy groups it uses maximal elements, because that shortens the loops.
---
```
10,:^{:x^>{x.@:&<+^>{.x>{x&@}*}/}/}%3>0.
```
at 40 chars (can probably still be improved) generates an optimal string, which is of length 999 chars:
```
100200300400500600700800901101201301401501601701801902102202302402502602702802903103203303403503603703803904104204304404504604704804905105205305405505605705805906106206306406506606706806907107207307407507607707807908108208308408508608708808909109209309409509609709809911121131141151161171181191221231241251261271281291321331341351361371381391421431441451461471481491521531541551561571581591621631641651661671681691721731741751761771781791821831841851861871881891921931941951961971981992223224225226227228229233234235236237238239243244245246247248249253254255256257258259263264265266267268269273274275276277278279283284285286287288289293294295296297298299333433533633733833934434534634734834935435535635735835936436536636736836937437537637737837938438538638738838939439539639739839944454464474484494554564574584594654664674684694754764774784794854864874884894954964974984995556557558559566567568569576577578579586587588589596597598599666766866967767867968768868969769869977787797887897987998889899900
```
Trying to make this do reverse strings runs into problems with omitting the multiples of 111.
To see that 999 is the optimal length (since my brief comments above don't convince everyone), start from the full de Bruijn sequence which (taken as a cyclic string) contains every 3-digit sequence of characters from 0 to 9. Since there are 1000 of them, it must be at least 1000 characters long; that it can be precisely 1000 characters long is usually proven by an Eulerian walk on a graph whose nodes are two-digit sequences `xy` with 10 edges, each labelled with one digit `z`, which take `xy` to `yz`.
We don't need sequences beginning `0`, so given a de Bruijn sequence we can rotate to put `000` at the end. Then we don't need either of the sequences which wrap round to the beginning, but we do need two of the `0`s to finish the sequence starting with the digit before `000`, so we can delete one of them to get a 999-character string. Every remaining `0` is used in a number which doesn't begin with `0`.
[Answer]
### GolfScript, 17 characters
```
999,{`1$1$?0<*+}/
```
Plain approach to add each number if not already present in the string (note: 999 is not checked or added, but contained already in the output).
Output is 1133 characters:
```
01234567891011131415161718192021222425262728293032333536373839404344464748495054555758596065666869707677798087889099100102103104105106107108109110112114115116117118119120124125126127128129130132133134135136137138139140142143144145146147148149150152153154155156157158159160162163164165166167168169170172173174175176177178179180182183184185186187188189190193194195196197198199200203204205206207208209219220221223225226227228229230231235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290294295296297298299300304305306307308309311329330332334336337338339340342346347348349350354355356357358359360364365366367368369370374375376377378379380384385386387388389390395396397398399400405406407408409422439440443445447448449450453457458459460465466467468469470475476477478479480485486487488489490496497498499500506507508509533549550554556558559560564568569570576577578579580586587588589590597598599600607608609644659660665667669670675679680687688689690698699700708709755769770776778780786790797799800809866877879880887888897898899900908932943954965976979987989
```
[Answer]
I don't have any code, but I thought someone might appreciate this intuitive proof that 999 characters is the lower bound to the length of the output:
First, every 1- and 2-digit number is part of a 3-digit number, so ignore everything less than 100. 100-999 inclusive is 900 3-digit numbers.
The most optimal way to solve the problem is if every character is used as much as possible. That means the numbers overlap as much as possible, like this:
```
123
234
345
```
The first number will therefore add 3 characters, and each subsequent number will add 1 character. That gives 3 + 899 = 902 characters as a lower bound.
However, when there is a zero, we can't use it to start a new 3-digit number. We can reuse it in the middle of another 3-digit number though, as long as it is not followed by another zero:
```
120
203 <- Ok.
034 <- not a number 100-999.
```
But:
```
100
002 <- not a number 100-999.
023 <- not a number 100-999.
```
Therefore, each zero which appears in the output extends the output by 1 character - except for the last two characters which may be zero as they do not overlap any further numbers:
```
???
??0
?00
```
There are 81 numbers with strictly one zero in the middle (?0?), 81 with strictly one zero at the end (??0), and 9 with two zeros (?00).
Every ??0 number can share a zero with either a ?0? number or a ?00 number, but not both. ?0? and ?00 can never share zeros, so there must be at least 81 + 9\*2 zeros in the output.
This gives a lower bound of 3 + 899 + 81 + 9\*2 - 2 = 999 characters.
Apologies if this is considered off-topic, but it was too long to fit in a comment.
[Answer]
## Golfscript - 13 bytes, 1315 output
```
991,{`.$2>>},
```
The above selects those numbers from *0-990* whose first digit is the largest digit of the number, i.e. the last digit of the sorted string representation is lexicographically less than the string itself. The logic is the following:
For a 3 digit number *abc*, if *a* is not the largest digit of the number, the number my be skipped, because it will be covered by one of two cases later on:
1. ***b < c*** (e.g. *123*)
Because *c* is the largest digit, the number *cab* will not be skipped. In this example *312* will not be skipped, nor will the next value *313*, which when concatenated (*312 313*) contains *123*.
2. ***b ≥ c*** (e.g. *132*)
Because *b* is the largest digit, the number *bca* will not be skipped. In this example *321* will not be skipped, nor will the next value *322*, which when concatenated (*321 322*) contains *132*. If *b = c* (e.g. *122*), this case also applies. The value *bca* will not be skipped, as before, and because *a* is necessarily less than *b*, *bc<a+1>* will not be skipped either. In this example, *221 222* contains *122*.
Because the above code tests the third digit, rather than strictly the last, all values from *0-99* are included in the result. The values from *1-99* may be skipped, however, because if every 3-digit sequence is present, then every 1-digit and 2-digit sequence must also be present.
The values from *991-999* may also be skipped, as the are generated by (*909 910*, *919 920*, ... *989 990*).
At 1315 bytes of output, this is comfortably under the problem's specification of less than 1500.
Output:
```
0123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101110111200201202210211212220221222300301302303310311312313320321322323330331332333400401402403404410411412413414420421422423424430431432433434440441442443444500501502503504505510511512513514515520521522523524525530531532533534535540541542543544545550551552553554555600601602603604605606610611612613614615616620621622623624625626630631632633634635636640641642643644645646650651652653654655656660661662663664665666700701702703704705706707710711712713714715716717720721722723724725726727730731732733734735736737740741742743744745746747750751752753754755756757760761762763764765766767770771772773774775776777800801802803804805806807808810811812813814815816817818820821822823824825826827828830831832833834835836837838840841842843844845846847848850851852853854855856857858860861862863864865866867868870871872873874875876877878880881882883884885886887888900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990
```
### Variation #1
**14 bytes, 1233 output**
```
991,{`.$-1>>},
```
By selecting strictly the last digit for comparison, rather than the third, many of the unnecessary values less than *100* are eliminated, shortening the resulting string.
```
101120212230313233404142434450515253545560616263646566707172737475767780818283848586878890919293949596979899100101110111200201202210211212220221222300301302303310311312313320321322323330331332333400401402403404410411412413414420421422423424430431432433434440441442443444500501502503504505510511512513514515520521522523524525530531532533534535540541542543544545550551552553554555600601602603604605606610611612613614615616620621622623624625626630631632633634635636640641642643644645646650651652653654655656660661662663664665666700701702703704705706707710711712713714715716717720721722723724725726727730731732733734735736737740741742743744745746747750751752753754755756757760761762763764765766767770771772773774775776777800801802803804805806807808810811812813814815816817818820821822823824825826827828830831832833834835836837838840841842843844845846847848850851852853854855856857858860861862863864865866867868870871872873874875876877878880881882883884885886887888900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990
```
### Variation #2
**16 bytes, 1127 output**
```
991,99>{`.$2>>},
```
By prying off all values less than *99* beforehand, the resulting string can be shortened even more.
```
99100101110111200201202210211212220221222300301302303310311312313320321322323330331332333400401402403404410411412413414420421422423424430431432433434440441442443444500501502503504505510511512513514515520521522523524525530531532533534535540541542543544545550551552553554555600601602603604605606610611612613614615616620621622623624625626630631632633634635636640641642643644645646650651652653654655656660661662663664665666700701702703704705706707710711712713714715716717720721722723724725726727730731732733734735736737740741742743744745746747750751752753754755756757760761762763764765766767770771772773774775776777800801802803804805806807808810811812813814815816817818820821822823824825826827828830831832833834835836837838840841842843844845846847848850851852853854855856857858860861862863864865866867868870871872873874875876877878880881882883884885886887888900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990
```
---
## Golfscript - 19 bytes, 1016 output
```
910,99>{`.2$\?)>+}/
```
The above counts from *99* to *909*, adding any value that hasn't already appeared (*909* would normally be the last value added in this way). Moving *99* to the front is an optimization to avoid needing *910* at the back.
Output:
```
99100101102103104105106107108109111112113114115116117118119120122123124125126127128129130132133134135136137138139140142143144145146147148149150152153154155156157158159160162163164165166167168169170172173174175176177178179180182183184185186187188189190192193194195196197198199200202203204205206207208209222223224225226227228229230233234235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290293294295296297298299300303304305306307308309333334335336337338339340344345346347348349350354355356357358359360364365366367368369370374375376377378379380384385386387388389390394395396397398399400404405406407408409444445446447448449450455456457458459460465466467468469470475476477478479480485486487488489490495496497498499500505506507508509555556557558559560566567568569570576577578579580586587588589590596597598599600606607608609666667668669670677678679680687688689690697698699700707708709777778779780788789790798799800808809888889890899900909
```
---
## Golfscript 26 bytes, 999 output
```
909.,99>{`..$.2><3$@?+>+}/
```
Note that the *1016* character string produced by the previous solution is nearly optimal, except for having two extra
digits for each multiple of *111* (i.e. `11111` instead of `111`, `22222` instead of `222`, etc.). The solution can be
made optimal by removing these extra digits (only inserting one digit at each of these values, instead of three), and by
rotating `909` to the front, eliminating a `9` (this differs from the previous versions, which moved `9100` to the back instead).
Unrolled and commented:
```
909.,99> # add 909 to the stack, and duplicate
# create an array from 0..908, and
# remove the first 99 elements (99..908)
{
`.. # stringify, duplicate twice
$.2>< # non-divisibility by 111 check
# true if the last char of the sorted
# string is greater than the first char
3$@? # first position of this number in
# the total string so far (-1 if not found)
+> # add the two previous results,
# and slice from that point
# (see explanation below)
+ # concat what remains to the total string
}/ # loop over the set
```
The logic to choose which characters are appended follows three cases:
1. ***111* ∤ *n*, *n* ⊄ *s***
The value from the first check is *1*, and from the second *-1*.
The slice will begin starting from index *0*; it will return the whole string.
2. ***111* ∤ *n*, *n* ⊂ *s***
The value from the first check is *1*, and from the second something *≥ 2*.
The slice will begin staring from index *≥ 3*; it will return an empty string.
3. ***111* ∣ *n*, *n* ⊄ *s***
The value from the first check is *0*, and from the second *-1*.
The slice will begin starting from index *-1*; it will return the last character only.
The sum of the logic is that any value which hasn't yet appeared will be appended in whole - unless it is a multiple of *111*, in which case only one character will be appended. All other values will be ignored.
Note that the string produced is different than the optimal one produced by [Peter Taylor's answer](https://codegolf.stackexchange.com/a/13091/4098).
History:
```
899,{101+.111%{`.2$\?0<*}{3/9%}if+}/
899,{101+`.2$\?0<\.~111%2*)<*+}/0
899,{101+`.2$\?0<\..2>-!2*>*+}/0
899,{101+`...2>|,1|<2$@?0<*+}/0
999,{`..$.2>>2*>2$@?0<*+}/3>0
899,{101+`..$.2><3$@?+>+}/0
```
Output:
```
909910010110210310410510610710810911121131141151161171181191201221231241251261271281291301321331341351361371381391401421431441451461471481491501521531541551561571581591601621631641651661671681691701721731741751761771781791801821831841851861871881891901921931941951961971981992002022032042052062072082092223224225226227228229230233234235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290293294295296297298299300303304305306307308309333433533633733833934034434534634734834935035435535635735835936036436536636736836937037437537637737837938038438538638738838939039439539639739839940040440540640740840944454464474484494504554564574584594604654664674684694704754764774784794804854864874884894904954964974984995005055065075085095556557558559560566567568569570576577578579580586587588589590596597598599600606607608609666766866967067767867968068768868969069769869970070770870977787797807887897907987998008088098889890899900
```
[Answer]
## Perl, ~~37 34 33~~ 32 (~~1136~~ 1132 characters)
```
for$@(1..999){$_.=$@x!/$@/}print
```
~~for$@(1..999){$\_.=$@if!/$@/}print~~
~~for$i(1..999){$\_.=$i if!/$i/}print~~
~~for(1..1e3){$s.=$\_ if$s!~/$\_/}print$s~~
Outputs:
```
12345678910111314151617181920212224252627282930323335363738394043444647484950545557585960656668697076777980878890991001021031041051061071081091101121141151161171181191201241251261271281291301321331341351361371381391401421431441451461471481491501521531541551561571581591601621631641651661671681691701721731741751761771781791801821831841851861871881891901931941951961971981992002032042052062072082092192202212232252262272282292302312352362372382392402432442452462472482492502532542552562572582592602632642652662672682692702732742752762772782792802832842852862872882892902942952962972982993003043053063073083093113293303323343363373383393403423463473483493503543553563573583593603643653663673683693703743753763773783793803843853863873883893903953963973983994004054064074084094224394404434454474484494504534574584594604654664674684694704754764774784794804854864874884894904964974984995005065075085095335495505545565585595605645685695705765775785795805865875885895905975985996006076086096446596606656676696706756796806876886896906986997007087097557697707767787807867907977998008098668778798808878888978988999009089329439549659769799879891000
```
### Shorter string: ~~38 37~~ 34 (1020 characters):
```
$_.=$@x!/$@/while$@=--$@%1e3;print
```
~~for($@=1e3;$@--;){$\_.=$@if!/$@/}print~~
~~for($i=1e3;$i--;){$\_.=$i if!/$i/}print~~
Outputs:
```
999998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888887886885884883882881880877876875874873872871870867866865864863862861860857856855854853852851850847846845844843842841840837836835834833832831830827826825824823822821820817816815814813812811810807806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555554553552551550544543542541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411410403402401400333332331330322321320312311310302301300222221220211210201200111110101100
```
Still not happy with the duplication especially the 99999 at the beginning! I think many more checks would create a lot more code though...
Edit: Added suggestion from @Peter Taylor
Edit 2: Some great suggestions from @primo! Thank you
[Answer]
## APL (20, output: 1020)
```
{∨/⍺⍷⍵:⍵⋄⍵,⍺}/⍕¨⍳999
```
Explanation:
* `{∨/⍺⍷⍵:⍵⋄⍵,⍺}`: if `⍺` is a substring of `⍵`, return `⍵`, else return `⍵,⍺`
* `/`: reduce over
* `⍕¨`: the string representation of each of
* `⍳999`: the integers from `1` to `999`.
Output:
```
9999989979969959949939929919909889879869859849839829819809789779769759749739729719709689679669659649639629619609589579569
55954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913
91291191090890790690590490390290190088888788688588488388288188087787687587487387287187086786686586486386286186085785
68558548538528518508478468458448438428418408378368358348338328318308278268258248238228218208178168158148138128118108
07806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735
73473373273173072672572472372272172071671571471371271171070670570470370270170066666566466366266166065565465365265165
06456446436426416406356346336326316306256246236226216206156146136126116106056046036026016005555545535525515505445435
42541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411
410403402401400333332331330322321320312311310302301300222221220211210201200111110101100
```
## APL (41, output: 999)
```
'0',⍨⊃{⍵,⍺⍴⍨(1=⍴∪⍺)∨3×~∨/⍺⍷⍵}/⌽⍕¨100+⍳898
```
Explanation:
* `⌽⍕¨100+⍳898`: `('999' '998' ... '101')` (in reverse order, because reduction goes right to left in APL, i.e. `F/a b c ≡ a F (b F c)`)
* `/`: reduce
* `⍵,⍺⍴⍨`: right argument, followed by the first `N` characters of the left argument, where `N` is:
* `3×~∨/⍺⍷⍵`: `3` if `⍺` is not a substring of `⍵`, otherwise `0`
* `(1=⍴∪⍺)`: `1` if `⍺` only has one unique characcter, otherwise `0`
* `∨`: greatest common divisor of the previous two values, so: `1` if `⍺` is not already in `⍵` and only has one unique character, `3` if `⍺` is not already in `⍵` but has more than one unique character, `0` otherwise.
* `'0',⍨`: add a zero to the end of the result
Output:
```
10110210310410510610710810911121131141151161171181191201221231241251261271281291301321331341351361371381391401421431441451
46147148149150152153154155156157158159160162163164165166167168169170172173174175176177178179180182183184185186187188
18919019219319419519619719819920020220320420520620720820922232242252262272282292302332342352362372382392402432442452
46247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290293294
29529629729829930030330430530630730830933343353363373383393403443453463473483493503543553563573583593603643653663673
68369370374375376377378379380384385386387388389390394395396397398399400404405406407408409444544644744844945045545645
74584594604654664674684694704754764774784794804854864874884894904954964974984995005055065075085095556557558559560566
56756856957057657757857958058658758858959059659759859960060660760860966676686696706776786796806876886896906976986997
00707708709777877978078878979079879980080880988898908999009099100
```
[Answer]
# Ruby: ~~50~~ 46 characters (1020 characters output)
```
s=""
999.downto(0){|i|s[n=i.to_s]||s+=n}
$><<s
```
Sample run:
```
bash-4.1$ ruby -e 's="";999.downto(0){|i|s[n=i.to_s]||s+=n};$><<s'
999998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888887886885884883882881880877876875874873872871870867866865864863862861860857856855854853852851850847846845844843842841840837836835834833832831830827826825824823822821820817816815814813812811810807806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555554553552551550544543542541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411410403402401400333332331330322321320312311310302301300222221220211210201200111110101100
```
Test run:
```
bash-4.1$ ruby -e 's="";999.downto(0){|i|s[n=i.to_s]||s+=n};$><<s' | ruby -ne 'p (0..999).reject{|i|$_[i.to_s]}'
[]
```
## Ruby: ~~102~~ 97 characters (999 characters output)
```
s=""
999.downto(0){|i|s[n=i.to_s]||[2,1].map{|j|n[0,j]==s[-j,j]&&s+=n[j,9]and break}&&s+=n}
$><<s
```
Sample run:
```
bash-4.1$ ruby -e 's="";999.downto(0){|i|s[n=i.to_s]||[2,1].map{|j|n[0,j]==s[-j,j]&&s+=n[j,9]and break}&&s+=n};$><<s'
999899799699599499399299199098898798698598498398298198097897797697597497397297197096896796696596496396296196095895795695595495395295195094894794694594494394294194093893793693593493393293193092892792692592492392292192091891791691591491391291191090890790690590490390290190088878868858848838828818808778768758748738728718708678668658648638628618608578568558548538528518508478468458448438428418408378368358348338328318308278268258248238228218208178168158148138128118108078068058048038028018007776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666566466366266166065565465365265165064564464364264164063563463363263163062562462362262162061561461361261161060560460360260160055545535525515505445435425415405345335325315305245235225215205145135125115105045035025015004443442441440433432431430423422421420413412411410403402401400333233133032232132031231131030230130022212202112102012001110100
```
Test run:
```
bash-4.1$ ruby -e 's="";999.downto(0){|i|s[n=i.to_s]||[2,1].map{|j|n[0,j]==s[-j,j]&&s+=n[j,9]and break}&&s+=n};$><<s' | ruby -ne 'p (0..999).reject{|i|$_[i.to_s]}'
[]
```
[Answer]
# JavaScript, 39
```
for(k=i="999";~k.indexOf(--i)?i:k+=i;);
```
1020 character output:
```
999998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888887886885884883882881880877876875874873872871870867866865864863862861860857856855854853852851850847846845844843842841840837836835834833832831830827826825824823822821820817816815814813812811810807806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555554553552551550544543542541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411410403402401400333332331330322321320312311310302301300222221220211210201200111110101100
```
Verification: `for(i=0;i<1000;i++)console.assert(k.indexOf(i)>=0)`
[Answer]
# Mathematica (~~62~~ 64 chars, 1002 output)
Because this makes use of a native function, I appreciate all the more the beauty of shorter solutions from scratch. Output is 1002 chars long.
```
<< Combinatorica`
"79" <> DeBruijnSequence["0"~CharacterRange~"9", 3]
"799798787770760750740730720710980970960950940930920910108908708608508408308208889998988081009909008007006005004003002000190180170160150140130120119118117116115114113112912812712612512412312213913813713613513413313214914814714614514414314215915815715615515415315216916816716616516416316217917817717617517417317218918818718618518418318219919819719619519419319212111029028027026025024023022922822722622522422392382372362352342332492482472462452442432592582572562552542532692682672662652642632792782772762752742732892882872862852842832992982972962952942932322202103903803703603503403393383373363353349348347346345344359358357356355354369368367366365364379378377376375374389388387386385384399398397396395394343330320310490480470460450449448447446445945845745645546946846746646547947847747647548948848748648549949849749649545444043042041059058057056055955855755695685675665795785775765895885875865995985975965655505405305205106906806706696686679678677689688687699698697676660650640630620610790780779778978879"
```
[Answer]
# Mathematica, 51 chars
```
""<>Table[ToString/@({i,j,k}-1),{i,10},{j,i},{k,i}]
```
Output(1155 chars):
```
000100101110111200201202210211212220221222300301302303310311312313320321322323330331332333400401402403404410411412413414420421422423424430431432433434440441442443444500501502503504505510511512513514515520521522523524525530531532533534535540541542543544545550551552553554555600601602603604605606610611612613614615616620621622623624625626630631632633634635636640641642643644645646650651652653654655656660661662663664665666700701702703704705706707710711712713714715716717720721722723724725726727730731732733734735736737740741742743744745746747750751752753754755756757760761762763764765766767770771772773774775776777800801802803804805806807808810811812813814815816817818820821822823824825826827828830831832833834835836837838840841842843844845846847848850851852853854855856857858860861862863864865866867868870871872873874875876877878880881882883884885886887888900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999
```
[Answer]
# Python - 53 ~~63~~, 1134 output
This is pretty brute forcish, but it is valid. Yes it has a leading zero, but it saves two characters by not having `range(1,1000)`.
```
s=''
for i in range(1e3):s+=`i`*(not`i`in s)
print s
```
The above throws a `DeprecationWarning` over the use of 1e3 in the `range()` call, but it saves a character over using 1000.
There is a slightly more optimal length output version as well, by reversing the string at the cost of ~~6~~ 5 characters **(thanks to r.e.s and filmor for the tips)**:
# Python - 58, 1021 output
```
s=''
for i in range(999,9,-1):s+=`i`*(not`i`in s)
print s
```
[Answer]
# Java-~~126~~ 98 chars (Java 6)
```
class b{static{String s="";for(int a=999;a>0;a--)s=s.contains(""+a)?s:s+a;System.out.println(s);}}
```
Output (1020 chars):
```
999998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888887886885884883882881880877876875874873872871870867866865864863862861860857856855854853852851850847846845844843842841840837836835834833832831830827826825824823822821820817816815814813812811810807806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555554553552551550544543542541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411410403402401400333332331330322321320312311310302301300222221220211210201200111110101100
```
Can reach a good (according to [Peter Taylor](https://codegolf.stackexchange.com/questions/13088/a-ring-to-rule-them-all-a-string-to-contain-them-all#comment25855_13088), but later he said 999 was optimal) String length by adding a few chars (+20 chars for ~~147~~ 118):
```
class b{static{String s="";for(int a=999;a>0;a--)s=s.contains(""+a)?s:(a+1)%111==0?s+a%10:s+a;System.out.println(s);}}
```
Output (1002 chars):
```
999899799699599499399299199098898798698598498398298198097897797697597497397297197096896796696596496396296196095895795695595495395295195094894794694594494394294194093893793693593493393293193092892792692592492392292192091891791691591491391291191090890790690590490390290190088878868858848838828818808778768758748738728718708678668658648638628618608578568558548538528518508478468458448438428418408378368358348338328318308278268258248238228218208178168158148138128118108078068058048038028018007776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666566466366266166065565465365265165064564464364264164063563463363263163062562462362262162061561461361261161060560460360260160055545535525515505445435425415405345335325315305245235225215205145135125115105045035025015004443442441440433432431430423422421420413412411410403402401400333233133032232132031231131030230130022212202112102012001110101100
```
**Edit**: Thanks to Fabinout for pointing out that Java 6 can save 28 chars.
[Answer]
# K, 33
```
{$[#ss[x]@y;x;,/x,y]}/["";$!1000]
```
Basically the same as Howards solution - 1133 characters.
```
01234567891011131415161718192021222425262728293032333536373839404344464748495054555758596065666869707677798087889099100102103104105106107108109110112114115116117118119120124125126127128129130132133134135136137138139140142143144145146147148149150152153154155156157158159160162163164165166167168169170172173174175176177178179180182183184185186187188189190193194195196197198199200203204205206207208209219220221223225226227228229230231235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290294295296297298299300304305306307308309311329330332334336337338339340342346347348349350354355356357358359360364365366367368369370374375376377378379380384385386387388389390395396397398399400405406407408409422439440443445447448449450453457458459460465466467468469470475476477478479480485486487488489490496497498499500506507508509533549550554556558559560564568569570576577578579580586587588589590597598599600607608609644659660665667669670675679680687688689690698699700708709755769770776778780786790797799800809866877879880887888897898899900908932943954965976979987989
```
[Answer]
## Windows PowerShell - 40, 1020 Output
```
999..0|%{$s+=if(!($s-match$_)){"$_"}};$s
```
Output:
```
999998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888887886885884883882881880877876875874873872871870867866865864863862861860857856855854853852851850847846845844843842841840837836835834833832831830827826825824823822821820817816815814813812811810807806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555554553552551550544543542541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411410403402401400333332331330322321320312311310302301300222221220211210201200111110101100
```
[Answer]
## Pyke, 13 bytes (noncompeting), string length 1133
Pyke is newer than the challenge and thus is noncompetitive .
```
k~mV~oi{!o`*+
```
[Try it here!](http://pyke.catbus.co.uk/?code=k%7EmV%7Eoi%7B%21o%60%2a%2B)
```
- o = 0
k~mV - repeat 1000 times, i = ""
~oi{ - str(o) in i
! - not ^
o`* - str(o++) * ^
+ - i += ^
```
[Answer]
# Haskell, 75 bytes - 1002 output
A sieve approach that returns a minimal solution.
```
(\n->head.filter(\s->and[show k`isInfixOf`s|k<-[1..n]]).map show$[1..])1000
```
Note that this solution is impractically slow.
[Answer]
# Powershell, 36 bytes, 1020 output
```
999..9|%{$s+=(,"$_")[$s-match$_]};$s
```
Output:
```
999998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888887886885884883882881880877876875874873872871870867866865864863862861860857856855854853852851850847846845844843842841840837836835834833832831830827826825824823822821820817816815814813812811810807806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555554553552551550544543542541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411410403402401400333332331330322321320312311310302301300222221220211210201200111110101100
```
## Alternative, 69 bytes, 1000 output
```
999..9|%{$s+=("$_",($x="$_"[-1]))[2*($s-match$_)+($s+$x-match$_)]};$s
```
Output:
```
9998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888788688588488388288188087787687587487387287187086786686586486386286186085785685585485385285185084784684584484384284184083783683583483383283183082782682582482382282182081781681581481381281181080780680580480380280180077767757747737727717707667657647637627617607567557547537527517507467457447437427417407367357347337327317307267257247237227217207167157147137127117107067057047037027017006665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555455355255155054454354254154053453353253153052452352252152051451351251151050450350250150044434424414404334324314304234224214204134124114104034024014003332331330322321320312311310302301300222122021121020120011101100
```
## Alternative, ~~82~~ 73 bytes, 999 output (minimum)
```
for(;$z=9..0|?{"000$x"-notmatch-join"$x$_"[-3..-1]}|%{"$_"}){$x+=$z[0]}$x
```
This is simplified algorithm from [Generate the shortest De Bruijn](https://codegolf.stackexchange.com/a/173125/80745) adapted for constants: alphabet=`9876543210` and length=`3`
Output:
```
999899799699599499399299199098898798698598498398298198097897797697597497397297197096896796696596496396296196095895795695595495395295195094894794694594494394294194093893793693593493393293193092892792692592492392292192091891791691591491391291191090890790690590490390290190088878868858848838828818808778768758748738728718708678668658648638628618608578568558548538528518508478468458448438428418408378368358348338328318308278268258248238228218208178168158148138128118108078068058048038028018007776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666566466366266166065565465365265165064564464364264164063563463363263163062562462362262162061561461361261161060560460360260160055545535525515505445435425415405345335325315305245235225215205145135125115105045035025015004443442441440433432431430423422421420413412411410403402401400333233133032232132031231131030230130022212202112102012001110100
```
---
Test script:
```
$f= {
#999..0|%{$s+=if(!($s-match$_)){"$_"}};$s
#999..9|%{$s+=("$_",($x="$_"[-1]))[2*($s-match$_)+($s+$x-match$_)]};$s-replace'1100','100'
#999..9|%{$s+=("$_",($x="$_"[-1]))[2*($s-match$_)+($s+$x-match$_)]};$s
#999..9|%{$s+=(,"$_")[$s-match$_]};$s-replace'(.)\1{3,}','$1$1$1'
#999..9|%{$s+=(,"$_")[$s-match$_]};$s-replace'(.)\1{3,}','$1$1$1'-replace'1100','0'
for(;$z=9..0|?{"000$x"-notmatch-join"$x$_"[-3..-1]}|%{"$_"}){$x+=$z[0]}$x
#999..9|%{$s+=(,"$_")[$s-match$_]};$s
}
$s=&$f
$s
"Length:"
$s.Length
"count(###)!=1:"
$x=@{}
0..($s.Length-3)|%{$s.Substring($_,3)}|Group|%{
$x[+$_.Name]=$_.Count
}
100..999|?{$x.$_-ne1}|%{,($_,+$x.$_)}|%{"$_"}
"count(##)!=10:"
$x=@{}
0..($s.Length-2)|%{$s.Substring($_,2)}|Group|%{
$x[+$_.Name]=$_.Count
}
10..99|?{$x.$_-ne10}|%{,($_,+$x.$_)}|%{"$_"}
"count(#)!=100:"
$x=@{}
0..($s.Length-1)|%{$s.Substring($_,1)}|Group|%{
$x[+$_.Name]=$_.Count
}
0..9|?{$x.$_-ne100}|%{,($_,+$x.$_)}|%{"$_"}
"All numbers:"
999-eq(1..999|?{$s-match$_}).Count
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 9 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage) and [1109 characters](https://tio.run/##yy9OTMpM/f//UVOLm4vf4aXxmX6H1/yPTf8PAA)
```
₄FDNå_iNì
```
Outputs:
```
90990190089989088981980980880079979879078978878077977870970870770069969869769068968868768067967867767066966866760960860760660059959859759659058958858758658057957857757657056956856756656055955855755650950850750650550049949849749649549048948848748648548047947847747647547046946846746646546045945845745645545044944844744644540940840740640540440039939839739639539439038938838738638538438037937837737637537437036936836736636536436035935835735635535435034934834734634534434033933833733633533430930830730630530430330029929829729629529429329028928828728628528428328027927827727627527427327026926826726626526426326025925825725625525425325024924824724624524424324023923823723623523423323022922822722622522422320920820720620520420320220019919719619519419319219118918818718618518418318218017917817717617517417317217016916816716616516416316216015915815715615515415315215014914814714614514414314214013913813713613513413313213012912812712612512412312212011811711611511411311211110910810710610510410310210110099919089888079787770696867666059585756555049484746454440393837363534333029282726252423222018171615141312119876543210
```
[Try it online](https://tio.run/##yy9OTMpM/f//UVOLm4vf4aXxmX6H1/z/DwA) or [verify it contains all numbers below 1000](https://tio.run/##yy9OTMpM/f//UVOLm4vf4aXxmX6H1/yPddEBCtgcnptd5mevpJCWX5qXopBYopCZl5JaoaBkX6nzHwA).
**Explanation:**
```
₄ # Push 1000
F # Loop N in the range [0,1000):
D # Duplicate the top value on the stack
Nå_i # If it does not contain N as substring yet:
Nì # Prepend N to it
# (Output implicitly after the loop)
```
[Answer]
# PHP, ~~48~~ 44 bytes
Thanks to @primo for reminding me of `ereg`.
```
for($i=1e3;--$i;ereg($i,$s)?:$s.=$i);echo$s;
```
or
```
for($i=1e3;ereg(--$i,$s)?$i:$s.=$i;);echo$s;
```
output: 1020 chars. requires PHP<7
## PHP 7, 48 bytes:
`ereg` has been removed in PHP 7
```
for($i=1e3;--$i;strstr($s,"$i")?:$s.=$i);echo$s;
```
If the second argument to `strstr` (or `strpos` and other string searching functions) is not a string, it will be used as an ascii code, so `$i` needs a cast to string.
[Answer]
# Groovy, 49 chars/bytes
I wasn't sure whether to do this as a function returning a string variable, or print out the result, so this just prints it to stdout. Using the regex matcher saved 2 bytes, using ternary operator instead of "if" saved another byte. The output string is 1133 characters.
```
a='';1000.times{a+=(a==~/.*$it.*/)?'':it};print a
```
Output:
```
01234567891011131415161718192021222425262728293032333536373839404344464748495054555758596065666869707677798087889099100102103104105106107108109110112114115116117118119120124125126127128129130132133134135136137138139140142143144145146147148149150152153154155156157158159160162163164165166167168169170172173174175176177178179180182183184185186187188189190193194195196197198199200203204205206207208209219220221223225226227228229230231235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290294295296297298299300304305306307308309311329330332334336337338339340342346347348349350354355356357358359360364365366367368369370374375376377378379380384385386387388389390395396397398399400405406407408409422439440443445447448449450453457458459460465466467468469470475476477478479480485486487488489490496497498499500506507508509533549550554556558559560564568569570576577578579580586587588589590597598599600607608609644659660665667669670675679680687688689690698699700708709755769770776778780786790797799800809866877879880887888897898899900908932943954965976979987989
```
[Answer]
# Game Maker Language, 1014 - String 1000
`show_message(909910010110210310410510610710810911121131141151161171181191201221231241251261271281291301321331341351361371381391401421431441451461471481491501521531541551561571581591601621631641651661671681691701721731741751761771781791801821831841851861871881891901921931941951961971981992002022032042052062072082092223224225226227228229230233234235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290293294295296297298299300303304305306307308309333433533633733833934034434534634734834935035435535635735835936036436536636736836937037437537637737837938038438538638738838939039439539639739839940040440540640740840944454464474484494504554564574584594604654664674684694704754764774784794804854864874884894904954964974984995005055065075085095556557558559560566567568569570576577578579580586587588589590596597598599600606607608609666766866967067767867968068768868969069769869970070770870977787797807887897907987998008088098889890899900)`
Also:
## Ruby, 1003 - String 1000
`p'909910010110210310410510610710810911121131141151161171181191201221231241251261271281291301321331341351361371381391401421431441451461471481491501521531541551561571581591601621631641651661671681691701721731741751761771781791801821831841851861871881891901921931941951961971981992002022032042052062072082092223224225226227228229230233234235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290293294295296297298299300303304305306307308309333433533633733833934034434534634734834935035435535635735835936036436536636736836937037437537637737837938038438538638738838939039439539639739839940040440540640740840944454464474484494504554564574584594604654664674684694704754764774784794804854864874884894904954964974984995005055065075085095556557558559560566567568569570576577578579580586587588589590596597598599600606607608609666766866967067767867968068768868969069769869970070770870977787797807887897907987998008088098889890899900'`
] |
[Question]
[
There is a well-known theorem that [any permutation can be decomposed into a set of cycles](http://en.wikipedia.org/wiki/Permutation#Notation). Your job is to write the shortest possible program to do so.
## Input:
Two lines. The first contains a number `N`, the second contains `N` distinct integers in the range `[0,N-1]` separated by spaces. These integers represent a permutation of `N` elements.
## Output:
One line for each cycle in the permutation. Each line should be a space-separated list of integers in cycle order.
Cycles can be output in any order, and each cycle can be output starting at any position.
## Example 1:
```
8
2 3 4 5 6 7 0 1
```
This input encodes the permutation 0->2, 1->3, 2->4, 3->5, 4->6, 5->7, 6->0, 7->1. This decomposes into cycles like this:
```
0 2 4 6
1 3 5 7
```
An equally valid output would be
```
5 7 1 3
2 4 6 0
```
## Example 2:
```
8
0 1 3 4 5 6 7 2
```
valid output:
```
0
1
4 5 6 7 2 3
```
[Answer]
**C ~~145~~ 134 Characters**
```
N,A[999],i,j,f;main(){gets(&i);for(;~scanf("%d",A+N);)N++;for(;j<N;j++,f=f&&!puts(""))while(i=A[j]+1)f=printf("%d ",j),A[j]=-1,j=--i;}
```
<http://www.ideone.com/BrWJT>
[Answer]
# Python 131 chars
```
input();d=dict((i,int(x))for i,x in enumerate(raw_input().split()))
while d:
x=list(d)[0]
while x in d:print x,;x=d.pop(x)
print
```
the ending newline is not needed
[Answer]
# J (between 2 and 32)
I'm not quite clear on i/o format, but I think `C.` would do, if the following output would be accepted:
```
C. 0 1 3 4 5 6 7 2
┌─┬─┬───────────┐
│0│1│7 2 3 4 5 6│
└─┴─┴───────────┘
```
(It looks better in the J terminal.)
If it needs to be a named function that complies to my best understanding of the i/o format, that'd be 32 characters, of which 30 are for output format conversion...
```
g=:>@(":L:0)@(C.@".@}.~>:@i.&LF)
```
In action:
```
g=:>@(":L:0)@(C.@".@}.~>:@i.&LF)
g
>@(":L:0)@(C.@".@}.~ >:@i.&(10{a.))
t
8
0 1 3 4 5 6 7 2
g t
0
1
7 2 3 4 5 6
```
## Explanation:
J is executed from right to left (practically). `@` is a 'function' (not technically a function, but that's close enough) to combine functions.
* `i.&LF` - find the first index of `LF`, a predefined variable
containing ASCII character number 10, the line feed.
* `>:` - find the first `LF`, and increment it's index by one. We don't actually want the linefeed, we want the array that follows it.
* `}.~` - Selects the part of the input that we want.
* `".` - Since the input format is valid J (*\*\õ/\**) we can just use the `eval` verb (I know it's not actually called `eval`.) to turn it into an array
* `C.` - Pure magic. I really have no idea what this does, but it seems to work!
* `":L:0` - Representation. Turns the output of `C.` into a boxed sequence of strings
* `>` - Unbox. The actual output is actually a string array (there are spaces behind the first to numbers of the example).
[Answer]
## Haskell, 131 characters
```
n%l|all(>n)l=(n:l>>=(++" ").show)++"\n"|1<3=""
c(_:a)=a>>=(\n->n%(takeWhile(/=n)$iterate(a!!)$a!!n))
main=interact$c.map read.words
```
* Edit: (135 -> 131) `>=` became `>`, eliminated two `tail` calls though pattern matching & pre-application of `a!!`.
[Answer]
# C (sort of), 139 chars
```
n,j,t,a[999];main(){scanf("%*i");for(;scanf("%i",a+n)>0;)n++;while(n--)if(a[j=n]+1){for(;t=a[j]+1;a[j]=-1,j=t)printf("%i ",--t);puts("");}}
```
The final newline is not included.
I said "sort-of" because AFAIK for example
1. it's not legal to omit declaration for variadic functions (ANSI C89: 3.3.2.2)
2. `int` cannot be omitted for variable declaration (I didn't find where it's said it can be omitted and implicit type declaration is only described for functions. The grammar specification in the standard is basically useless as accepts much more than valid C declarations, for example `double double void volatile x;`)
3. a newline at the end of a non-empty source file is mandatory (ANSI C89: A.6.2)
but the above code compiled with `gcc -ocycles cycles.c` apparently works anyway.
[Answer]
# Clojure, 145
```
(let[v(vec(repeatedly(read)read))](loop[a(set v)b 0](cond(a(v b))(do(print" "b)(recur(disj a(v b))(v b)))(seq a)(do(prn)(recur a(first a)))1"")))
```
Somewhat ungolfed, and broken out into a function (input must be a vector, which is what (vec(repeatedly(read)read)) from above produces):
```
(defn p [v]
(loop [a (set v) b 0]
(cond
(a (v b)) (do (print" "b) (recur (disj a (v b)) (v b)))
(seq a) (do (prn) (recur a (first a)))
1 "")))
```
(Wow, just noticed this challenge is over 3 year old. Oh well, had fun doing it anyways!)
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 17 bytes
```
ḲVJ’,Ɗy¥Ƭ`ZṢ€Q€QG
```
[Try it online!](https://tio.run/##y0rNyan8///hjk1hXo8aZuoc66o8tPTYmoSohzsXPWpaEwjC7v//W/w3UjBWMFEwVTBTMFcwUDAEAA "Jelly – Try It Online")
or with modern I/O standards, [14 bytes](https://tio.run/##y0rNyan8/9/rUcNMnWNdlYeWHluTEPVw56JHTWsCQfj/4fajkx7unKEZ@f9/tJGOgrGOgomOgqmOgpmOgrmOgoGOgmGsjkI0iMaQNIoFAA).
Takes `N` on STDIN and the list of numbers as the first command line argument
The last 5 bytes feel far too long for such a simple task
## How it works
```
ḲVJ’,Ɗy¥Ƭ`ZṢ€Q€QG - Main link. Takes a string S on the left
Ḳ - Split S on spaces
V - Evaluate each element. Call this list of integer L
¥ - Group the previous 2 links into a dyad f(A, L):
Ɗ - Group the previous 3 links into a monad g(A):
J - Length range of A
’ - Decrement to use 0 indexing
, - Pair with A
y - Transliterate L using the mapping from g(A)
Ƭ - While results are unique, repeatedly apply f(A, L),
` - starting with f(L, L)
Z - Transpose
Ṣ€ - Sort each subarray
Q€ - Deduplicate each subarray
Q - Deduplicate the whole array
G - Join each subarray with spaces and the subarrays by newlines
```
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 110 bytes
```
(n,N=[])=>n.flatMap(e=>~N.indexOf(e)?[]:[(U=(T,P=T[T.length-1])=>N.push(P)&&(e==n[P]?T:U([...T,n[P]])))([e])])
```
[Try it online!](https://tio.run/##dYy9CoMwFEb3PojcC9fQ2j8Qok9Q6xCnkEE0UUtIpNrSqa@e6lYKHb/DOd@tftZTcx/GOXa@1cHwAI4KLhXyzDFj6/lSj6B59i7Y4Fr9uhrQmEuVSqg4CCq5kIJZ7bq5j3drVrDxMfVQYhQtIXeyVLlIK5CMMUHrVIgIUitUGBrvJm81s74DAzKhPR3oSCc605aWP9z8GAv9cpI/xsrDBw "JavaScript (Node.js) – Try It Online")
This is the version which takes in a list of integers and outputs a 2d list, where each sublist is a cycle.
[This version](https://tio.run/##jc2/CsIwEMfx3adwkjs4D/8rQvQJrB3iFIINNdVKSIqt4uSr16qDdXO7H3w/3NncTJle8qLq@3CwdSZq2JMhLwyXhcurpJtQJJRGsfKcOVNtTAFWrB4R5/5g79sMLK6VXirYCZAUC6kkO@uP1ak/fLGIi2t5ghh7vQYKr2K9lssdKGaW9JoaEUFZjZrPIffNS/wcnaROgy@Ds@zCETJYkBrRmCY0pRnNaUDDL8FOu/1db9nULTv6V44/st3XTw) takes in the number of numbers (not used). The numbers are taken as a space-separated string, and the function returns a string formatted as described in the question. It is 141 bytes long.
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 59 bytes
```
x=>x.flatMap(g=a=>1/x[a]?[[a,...g(x[a],x[a]=g)[0]||[]]]:[])
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@7/C1q5CLy0nscQ3sUAj3TbR1s5QvyI6MdY@OjpRR09PL10DxNMBEbbpmtEGsTU10bGxsVbRsZr/k/PzivNzUvVy8tM10jSijXSMdUx0THXMdMx1DHQMYzU1udBUAEWR1BjhUAES/w8A "JavaScript (Node.js) – Try It Online")
# [JavaScript (Node.js)](https://nodejs.org), 60 bytes
```
x=>x.flatMap(g=a=>[1/x[a]?[a,...g(x[a],delete x[a])[0]]:[]])
```
[Try it online!](https://tio.run/##dcpNCsIwEIbhvadwmcAY2/pTEFJP4AmGWQztJCihKTZIbh/NTgR33/fyPPjF6/i8L2k3x0mKsyXbIRsXON14Ud6yHbDdZ2S6IoMxxqt6YJIgSbZ1a2yILkikyxjnNQYxIXrlFHZwgCOc4Aw9NNCS1psf8alfpvsjai9v "JavaScript (Node.js) – Try It Online")
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 46 bytes
```
Needs["Combinatorica`"];Combinatorica`ToCycles
```
Complete code with test cases is:
```
Needs["Combinatorica`"];
Combinatorica`ToCycles /@
{
{3, 4, 5, 6, 7, 8, 1, 2},
{1, 2, 4, 5, 6, 7, 8, 3},
{1, 2, 3},
{1 , 2 , 4 , 5 , 6, 7 , 8, 3}
}
// Grid
```
$$
\left(
\begin{array}{ccc}
\{3,5,7,1\} & \{4,6,8,2\} & \text{Null} \\
\{1\} & \{2\} & \{4,5,6,7,8,3\} \\
\{1\} & \{2\} & \{3\} \\
\{1\} & \{2\} & \{4,5,6,7,8,3\} \\
\end{array}
\right)
$$
[Answer]
Python3.8, 129 chars
```
def v(i):_=a[i];a[i]=-1;return~_ and[i]+v(_)or[]
input()
for i in range(len(a:=[*map(int,input().split())])):~a[i]and print(v(i))
```
[Answer]
# MATL, 20 bytes
```
:wQy"yy)]v"@quS!]Xhu
```
[Try it out!](https://matl.suever.net/?code=%3AwQy%22yy%29%5Dv%22%40quS%21%5DXhu&inputs=8%0A%5B2+3+4+5+6+7+0+1%5D&version=22.4.0)
Takes the liberty of assuming the second input is inside a pair of square brackets, but otherwise sticks to the requirements (spending 2 bytes on the 0-indexing for example). Works pretty similar to caird coinheringaahing's Jelly answer.
] |
[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/80761/edit).
Closed 7 years ago.
[Improve this question](/posts/80761/edit)
*This is not a duplicate of [this question](https://codegolf.stackexchange.com/questions/73827/taxi-me-some-numbers). This is asking for the nth number that can be represented as the sum of two cubes in two different ways, while that is asking for the n-th number that can be expressed as the sum of two cubes in n ways.*
## Introduction
I was just watching *The man who knew Infinity*, and I thought it would make a good challenge.
## So, what's the challenge??
You must write a program that will calculate the *n*-th number that can be expressed as the sum of two cubes, not in one way, but **exactly** two.
## Specifications
* You may output either the *n*-th number, or an array up to (and including) the *n*-th value.
* You must output both sums of cubes (however you'd like), and the number, for each output.
* You cannot hardcode any solutions.
* Runtime will be my Arch Linux laptop with 16 GB of RAM and an Intel i7 processor.
* Negitive numbers are not used.
## Winning
* The winner is the solution who's runtime for `n = 10` (in seconds) times the code size is smallest.
]
|
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
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).
Closed 7 years ago.
[Improve this question](/posts/79741/edit)
I want to write 7 assembly instructions (28 bytes) that runs a logical equivalent of this C snippet:
```
c = a + b + 6;
while (c > 5) {
c = c - a;
b = b + 1;
}
```
However, there are restrictions to the allowed instructions:
```
add, addi, sub, subi, slt, slti, bne
```
`a`, `b`, and `c` are located in registers `$t0`, `$t1`, and `$s0` respectively. Assume they are declared as signed 32 bit integers. You may use other registers as necessary but you may not assume an initial value for any registers except `$0` which is wired to ground (always 0, even if assigned to).
The best attempt to date is thanks to @Smac89 with the following assembly:
```
addi $s1, $t0, 6 # d = a + 6
add $s0, $s1, $t1 # c = d + b
loop: slti $t2, $s0, 6 # f = (c < 6)
bne $t2, $0, exit # (c < 6) ? exit
sub $s0, $s0, $t0 # c = c - a;
addi $t1, $t1, 1 # b = b + 1;
bne $s1, $t0, loop # (d != a) ? loop; always true
exit:
```
]
|
[Question]
[
Write a program that prints its own source code out backwards, in other words an *eniuq*.
**Scoring:**
* +50 if you use pull data from the Internet.
* +25 if you read your own source code.
* +1 point per character
* Lowest score wins.
**Rules:**
* No using other files (e.g. `reverse.txt`)
* Minimum code length is two characters.
* **Your program cannot be a palindrome.**
[Answer]
## [huh?](http://esolangs.org/wiki/Huh%3F), 5 characters
```
!hcuO
```
I actually have NO idea how it works, but If you download the interpreter, and if you write `!hcuO`, then you get `Ouch!`
To run this, you need to execute the program like this:
```
huh.exe !hcuO
```
It will actually look for a file called `!hcuO`, but it doesn't exist, so it outputs `Ouch!`
[Answer]
# Mathematica, 3 chars
```
a 2
```
`a 2` means `a` times 2. So the answer is `2 a`.
[Answer]
# GolfScript - 2
```
1
```
(ie `\n1` where `\n` is the newline character)
Output:
```
1
```
(ie `1\n`)
---
To quote [Ilmari](https://codegolf.stackexchange.com/questions/16021/print-your-code-backwards-reverse-quine/16040#16040):
>
> GolfScript automatically appends a newline to the end of the output
>
>
>
Thus a newline followed by a number will print the number followed by a newline.
[Answer]
## [H9+](http://esolangs.org/wiki/H9%2B), 13 characters
```
!dlrow ,olleH
```
As the web page says, all characters that are not `H`, `9` or `+` are ignored, so my program will print `Hello, world!`
[Answer]
## Javascript: 34 characters
```
reifitnedi detcepxenU :rorrExatnyS
```
outputs `SyntaxError: Unexpected identifier`, at least in the Chrome console
[Answer]
# Python, ~~43~~ 41
```
_=']0~::[_%%_ tnirp;%r=_';print _%_[::~0]
```
[Answer]
# Mathematica, 2 bytes
```
1#
```
Outputs:
>
> #1
>
>
>
[Answer]
## TI-BASIC, 2
```
i2
```
Where `i` is the imaginary number.
Outputs `2i`
[Answer]
# BASIC, ~~22~~ ~~12~~ 7 characters
:-)
```
1 enil ni rorre xatnyS
```
**EDIT:** If you're allowed to enter the program in immediate mode, then this could be reduced to `rorre xatnyS` (12 characters).
In BBC BASIC, you only need 7 characters:
```
ekatsiM
```
[Answer]
**ksh** (**21 chars**)
```
$ dnuof ton :found :hsk
ksh: dnuof: not found
```
---
**bash** (31 chars)
```
$ dnuof ton dnammoc :found :hsab-
-bash: dnuof: command not found
```
---
**sh** (29 chars)
```
$ dnuof ton dnammoc :found :hs-
sh: dnuof: command not found
```
This one could not work on some Linux distributions, but works on OSX.
---
**tcsh** (26 chars)
```
$ .dnuof ton dnammoC :found.
.dnuof: Command not found.
```
---
**csh** (26 chars)
```
% .dnuof ton dnammoC :found.
.dnuof: Command not found.
```
---
Above should work on all \*unix based OS.
---
Assumptions:
* You don't have `dnuof` command or alias present.
---
**bash** (2-4 chars)
This one most likely doesn't qualify, but I'll share it as curiosity.
Assuming the previous shell command in Bash was `$!`. The following command:
```
!$
```
will produce: `$!`.
[Answer]
# C++ 472 characters
A lot of characters but I cant think of a simpler way in a c-based language.
```
#include<iostream>
#include<string.h>
#define p(t) std::cout<<'}'<<';'<<')'<<strrev(&std::string(#t)[0])<<t;
char* strrev(char*p){char*t=p;char*q=p;while(q&&*q)++q;for(--q;p<q;++p,--q)*p=*p^*q,*q=*p^*q,*p=*p^*q;return t;}
int main(){p("(p{)(niam tni};t nruter;q*^p*=p*,q*^p*=q*,q*^p*=p*)q--,p++;q<p;q--(rof;q++)q*&&q(elihw;p=q*rahc;p=t*rahc{)p*rahc(verrts *rahc;t<<)]0[)t#(gnirts::dts&(verrts<<')'<<';'<<'}'<<tuoc::dts )t(p enifed#>h.gnirts<edulcni#>maertsoi<edulcni#");}
```
[Answer]
# Befunge 98 - 10 chars
```
"8k,'!1+,@
```
This works if your interpreter does not interpret wrapped lines after `"` as adding an extra space. If your interpreter does interpret wrapped lines like that, then this 11 char solution works ([because duplicate spaces in a string literal are interpreted as one](http://quadium.net/funge/spec98.html#Strings)):
```
"9k,'!1+,@
```
---
If I can use `g` without penalty, then these also work (7 and 8 chars respectively):
```
"5k,g,@
```
and
```
"6k,g,@
```
[Answer]
## GolfScript, 12 chars
```
"-1%.`"-1%.`
```
This code takes the double-quoted string `"-1%.`"`, reverses it (`-1%`), duplicates it (`.`) and un-evals (```) the second copy, restoring the double quotes around it.
### Previous entry (13 chars):
```
{`'.~'+-1%}.~
```
Based on the 8-char quine `{'.~'}.~` from [this answer](https://codegolf.stackexchange.com/questions/5083/create-a-rotating-quine/5160#5160); the extra 5 chars are needed to stringify and reverse the output.
Ps. Note that GolfScript automatically appends a newline to the end of the output. If this is counted as part of the output, a corresponding newline can be prepended to either version of the code without affecting the output, for a cost of one extra char.
[Answer]
# [Fission](http://esolangs.org/wiki/Fission), 6 bytes
A rare case of a generalised quine that is the same length as [the normal quine](https://codegolf.stackexchange.com/a/50968/8478):
```
"LO+!'
```
The idea is the same as that of the normal quine, but we're using a left-going atom (starting at the `L`) so that print mode traverses the code in the opposite order.
[Answer]
## Ruby, 60
```
puts(2,s=<<2.chop.reverse,s)
puts(2,s=<<2.chop.reverse,s)
2
```
Based on a classic Ruby quine.
[Answer]
## Perl, 41
```
$_=q{print~~reverse"\$_=q{$_};eval"};eval
```
Old 52 character answer (27+25 penalty)
```
open+0;print ~~ reverse <0>
```
Reads its own source, stores the reverse in a scalar, and prints that.
[Answer]
# J: 26
**Standard quining** *(26 chars)*: by defining a function and passing it its own definition, in quotes:
```
|.(,],2#{:)'|.(,],2#{:)'''
```
Could probably be made shorter.
**J-specific** *(33 chars)*: by defining a variable and asking what file the variable was defined in, i.e. this one, then printing out the contents of that file:
```
1!:2&2|.1!:1(4!:4 a=:<'a'){4!:3''
```
Must be saved & run from a script (i.e. not in the REPL, because then the answer to the question is "your argument wasn't defined in a file", so there's no file to read).
[Answer]
# [><>](http://esolangs.org/wiki/Fish), 25 bytes
I was surprised to find this hadn't been done yet. :)
```
...yhsif sllems gnihtemoS
```
Paste code [here](https://fishlanguage.com/playground) and run it.
`.` is the Jump command, popping `x` and `y` off the stack, and moving the IP to `(x, y)` in the code box. In this case, the stack is empty, so the language's only error message is printed:
```
Something smells fishy...
```
[Answer]
# [Microscript](https://esolangs.org/wiki/Microscript), 11 bytes
I kind of had to do this.
```
0"Caxq"Caxq
```
Surprisingly, this is actually shorter than the language's shortest known true quine. `q` and `a` are otherwise equivalent, except `q` adds wrapping quotes while `a` does not.
[Answer]
## PHP, 41 characters (+25)
Don't know if I understood the assignment correctly. But here's a PHP try:
```
while(!isset($s) || $s) echo isset($s) ? array_pop($s) : ($s = str_split(file_get_contents(__FILE__)) and null);
```
**edit:** this can be much shorter:
```
echo strrev(file_get_contents(__FILE__));
```
But since it can be that simple, this is probably not what is being asked...
[Answer]
# JavaScript jQuery ~~119~~ ~~92~~ ~~74~~ 70 characters
```
alert($("#answer-16051 pre code").text().split("").reverse().join(""))
```
Now using jQuery, as minitech suggested in the comments, and manually wrapping with `<pre><code>` so I can use `text()` without fear of other code blocks in this post interfering. Manually wrapping with `<h4>` was incompatible with chromeium when I tested it, so now it should work in most browsers.
This program, if run from this page, finds the code block directly above, reverses its contents, and puts it in an alertbox.
Its easy enough to verify, just paste it into the dev console.
[Answer]
# UNIX shell, 31
Real solution at **52 characters:**
```
A='printf "A$ lave;\047`echo $A|rev`\047=A"';eval $A
```
But beware! Honesty doesn't pay off in today's world! Penalty is too low!!
**6 chars + 25 = 31:**
```
rev $0
```
[Answer]
## MATLAB, 78 characters:
```
|
.snoisserpxe ro stnemetats BALTAM ni dilav ton si retcarahc tupni ehT :rorrE
```
Note that the solution requires you to begin with a special character (alt+0160) and that it prints exactly the reversed message. (Unlike the python solution)
[Answer]
## MS-DOS, 24 bytes
```
eman elif ro dnammoc daB
```
Output:
```
Bad command or file name
```
[Answer]
# Windows 10 .EXE, 98 bytes
```
.rehsilbup erawtfos eht htiw kcehc ,CP ruoy htiw noisrev a dnif oT
.CP ruoy no nur t'nac ppa sihT
```
[](https://i.stack.imgur.com/Uo1FF.png)
[Answer]
# JavaScript, 62
```
function f(){alert((f+'f()').split('').reverse().join(''))}f()
```
Works for me on latest Chrome (v 31.0.1650.63). Some other browsers may give a different output. (If you reverse that output, then it would work :P)
[Answer]
# SmileBASIC, ~~118~~ 102 bytes
```
FOR I=-101TO.?MID$(("+CHR$(34))*3,30,102)[-I];:NEXTFOR I=-100TO.?MID$(("+CHR$(34))*3,30,102)[-I];:NEXT
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 12 bytes
```
"iQ ²w"iQ ²w
```
[Try it online!](https://tio.run/##y0osKPn/XykzUOHQpnIo9f8/AA "Japt – Try It Online")
Based off the [standard Japt quine](https://codegolf.stackexchange.com/a/71932/39244)
### Explanation
```
"iQ ²w" // Take this string. iQ ²w
iQ // Insert a quote. "iQ ²w
² // Double. "iQ ²w"iQ ²w
w // Reverse. w² Qi"w² Qi"
// Implicitly output.
```
[Answer]
# Windows command prompt, 93 bytes
```
.elif hctab ro margorp elbarepo ,dnammoc lanretxe ro lanretni na sa dezingocer ton si 'file.'
```
[](https://i.stack.imgur.com/ZrM7A.png)
[Answer]
## JavaScript, 56
```
($=_=>_!=$._?_?$(_.slice(1))+_[0]:')':$('($='+$+')('))()
```
] |
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
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).
Closed 8 years ago.
[Improve this question](/posts/72022/edit)
You're given two numbers a and b in base 31 numeral system and number k with no more than 10000 decimal digits. It is known that b is divisor of a. The task is to find last k 31-based-digits of quotient a/b.
The solution with fastest proved asymptotics in length of max(a,b) wins. I'll put a bound of 10^5 on length of a and b.
Test example:
INPUT: a = IBCJ, b = OG, k = 5
OUTPUT: 000N7
]
|
[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/71736/edit).
Closed 3 years ago.
[Improve this question](/posts/71736/edit)
# Introduction
I have recently started playing [clickerheroes](http://clickerheroes.com) again. In the recent patch they introduced a new mechanic to mercenaries: their lifetime. Instead of having a random chance at dying now they have a certain lifespan given by a [geometric distribution](https://en.wikipedia.org/wiki/Geometric_distribution) of p = 0.2. They can be sent on quests to accumulate a premium currency called rubys. When they die you can revive them paying rubys.
# The challenge
The amount of rewards they bring home are scaling linear with their level, while the revivecost is scaling exponentially, so at a certain level it is better to not revive a mercenary and instead hire a new one.
I wrote some code simulating this challenge but found that it was pretty long and there certainly must be a way to make it shorter.
Your job is to do that and find the level where not reviving makes the ruby return per day reach a maximum.
# More information on mercenaries
* The lifespan of a mercenary is given by a geometric distribution with p = 0.2 in days. Within the day the distribution is linear. Meaning that the chance to die at any given minute is the same as any other minute that day.
* Doing a quest reduces the lifespan by the duration of that quest.
* You can always choose from 4 quests.
* The quest available are random and split in 2 parts.
* The main objective is choosen from a pool of 5 where only 1 is finding rubies so the chance that it is a ruby quest is 1/5.
* The other value is the duration, the possibilities are 5 min, 15 min, 30 min, 1 hour, 2 hours, 4 hours, 8 hours, 1 day and 2 days.
* The reward is given by the base value 0.01112 rubies times the level times the duration/5min (eg 30 min = 6) times a durations factor, since longer quest gives diminishing returns, given in the table below.
```
5 min 1
15 min 0.8594
30 min 0.7785
1 hour 0.624
2 hours 0.5467
4 hours 0.4687
8 hours 0.3903
1 day 0.3125
2 days 0.25
```
* This means we will always choose the shortest ruby quest and if there isn´t one the shortest other quest.
* The cost to revive a mercenary is `10 + ceiling(1.5^level)`
* After reviving the quest is finished and then a new lifespan is generated
* The level is going up by 1 for every day the mercenary spent questing and it starts at 1.
# Input and Result
This program should require no input. In the case that your language is not able to generate values of a geometric distribution you may take random values from [this](http://pastebin.com/UhLaArkC) list.
The result is a single number that represents at what point a mercenay should be discarded instead of revived.
The precision requirement is not a fixed value like 10%, but instead the accuracy should increase the more repetitions you run, so a perfect value should be theoretically possible given unlimited computation power.
The result of my simulation looks like this:
[](https://i.stack.imgur.com/kQfaR.jpg)
I used 50000 mercenarys per revive cap. Below 10000 gives spiky bits due to randomness
]
|
[Question]
[
**Your task** is to program a robot so that it reaches the hole in the ground on each of the maps within reasonable time. If the robot reaches the hole, it falls down into it and thus victory is assured, even if the program never stops running.
Since the robot has to be programmed by manually punching in ones and zeroes, you want to solve the problems using as few commands as possible. Labels are translated to positions by the assembler and integrated into the `gotoblocked` and `call` commands, so the programmer never has to punch them into the robot. Therefore, they do not count towards the score. If the robot tries to move into a wall or off the map, nothing happens.
**The language** consists of these statements:
* `forward` move the robot forward one step
* `right` rotate 90 degrees clockwise
* `left` rotate 90 degrees counter-clockwise
* `for X {A1 A2 .. An}` repeat commands `A1, A2, ..., An` `X` times
* `call X` call a subroutine, beginning at label X
* `return` return from the subroutine
* `gotoblocked X` jump to label X if there is a wall immediately in front of the robot
* `mylabel:` a label used by `call` and/or `gotoblocked`. Loops may not contain any labels. Labels may only contain letters.
**The input** files consist of:
`testcase_name`
`N` `M`
and then an `N` by `M` grid of:
* `.` empty square
* `#` blocked square
* `M` the hole in the ground that we want to end up in
* `<` `>` `^` `v` starting position of the robot, directed left, right, up or down, respectively.
**The maps** can be found at <http://progolymp.se/uploads/robot.zip>
Your task is to solve all the maps.
**Validation:**
The code you submit will be executed against all the test cases, starting at the label `testcasename` for each map. Follow the formatting in the example program.
**Scoring:**
The score is the number of statements (excluding labels) in the whole file, i.e. the code used to solve all testcases. Code reuse between testcases is ok.
**Example program** with starting points for testcases `robot_cross` and `robot_maze` (that solves neither):
```
walkandreturn:
for 100 {
forward
}
robotmaze:
gotoblocked done
right
right
for 100 {
for 3 {
forward
}
}
done:
return
robotcross:
for 100 {
call walkandreturn
right
}
```
**Automated judge** can be found at <http://progolymp.se/uploads/robot.jar>.
To test a file against the testcase `robot_ew_manuell`, add this to the end of your program file:
```
main:
call robotewmanuell
```
The judge starts execution at the label main, but we want it to start at `robotmaze` instead. This causes the judge to jump to where it should start, and saves me from having to write a new judge.
The actual judge can then be run like this:
`java -cp robot.jar parser.Runner robot_ew_manuell.in < my_solution.ans`
**Help wanted**
If you have a good place to mirror the files, or a way to post them on the site, please do.
This problem is based on the final problem of the 2016 online qualifier of Programmeringsolympiaden. <https://po.kattis.com/problems/robotoptimering> The original problem was authored by Johan Sannemo and Anton Grensjö. [CC BY-SA licensed](https://creativecommons.org/licenses/by-sa/3.0/), just like Stack Exchange.
]
|
[Question]
[
**This question already has answers here**:
[Cryptographic quine variant](/questions/8947/cryptographic-quine-variant)
(4 answers)
[Golf you a quine for great good!](/questions/69/golf-you-a-quine-for-great-good)
(453 answers)
Closed 8 years ago.
Challenge: make a program that outputs a [MD5 hash](https://en.wikipedia.org/wiki/MD5) of its source code.
You should not use tricks that would be considered cheating in a quine sense (discussed [here](https://codegolf.meta.stackexchange.com/questions/4877/what-counts-as-a-proper-quine)).
Using built-in functions and external libraries is allowed. The program should be a full program (not a function/subroutine). Code-golf: shortest solution (byte count) wins.
]
|
[Question]
[
Suppose you're given some distinct uppercase letters scattered in a rectangular array of otherwise-blank cells. Each cell in the array *belongs* to the letter *nearest* to it, defined as the letter reachable in the smallest number of horizontal and/or vertical steps -- no diagonal steps. (If a cell is equidistant from two or more nearest letters, it belongs to whichever of those letters is first in alphabetical order. A cell with an uppercase letter in it belongs to that letter.) *Boundary*-cells are those that are horizontally or vertically adjacent to one or more cells that do not belong to the letter that they themselves belong to.
**Write a procedure subprogram** with the following behavior, producing a kind of [Voronoi diagram](https://en.wikipedia.org/wiki/Voronoi_diagram) ...
**Input**: Any ASCII string composed only of dots, uppercase letters, and newlines, such that when printed it displays a rectangular array of the kind described above, with dots acting as blanks.
**Output**: A printout of the input string with each blank boundary-cell replaced by the lowercase version of the letter it belongs to. (The subprogram does the printing.)
**Example 1**
Input:
```
......B..
.........
...A.....
.........
.......D.
.........
.C.......
.....E...
.........
```
Output:
```
...ab.B..
....ab.bb
...A.abdd
aa...ad..
cca.ad.D.
..caeed..
.C.ce.edd
..ce.E.ee
..ce.....
```
A sketch highlighting the boundaries:
**Example 2**
Input:
```
............................U...........
......T.................................
........................................
.....................G..................
..R.......S..........F.D.E............I.
.........................H..............
.....YW.Z...............................
......X.................................
........................................
........................................
......MN...........V....................
......PQ................................
........................................
.............L...............J..........
........................................
........................................
....C...........K.......................
........................................
..................................A.....
...........B............................
```
Output:
```
..rt.....ts...sg......gduu..U.....ui....
..rt..T..ts...sg......gddeu......ui.....
...rt...ts....sg......gddeeu....ui......
....rttts.....sggggggGgdde.euuuui.......
..R.rywss.S....sfffffFdDdEeeeeeei.....I.
...ryywwzs.....sf....fddhHhhhhhhhi......
..ryyYWwZzs..sssffff.fddh.......hi......
..rxxxXxzzs.sllvvvvvffddh....hhhhi......
rrrxxxxnzzssl.lv....vfddh...hjjjjii.....
mmmmmmmnnnnnl.lv.....vvdh..hj....jai....
mmmmmmMNnnnnl.lv...V...vvhhj.....jaai...
ppppppPQqqql...lv.......vhj......ja.ai..
ppppp.pq.ql....lkv.....vjj.......ja..aii
cccccppqql...L.lkkv...vj.....J...ja...aa
.....cpqqlll..lk..kvvvvj........ja......
......cccbbbllk....kkkkj.......ja.......
....C...cb..bk..K......kj.....ja........
.......cb....bk........kjjjjjja.........
......cb......bk.......kaaaaaa....A.....
.....cb....B...bk......ka...............
```
Color enhancement:
[Answer]
# Python 3 - 424 422 417 332 295 characters:
```
def v(s):
w=s.find("\n")+1;n=(-1,1,-w,w);r=range(len(s));x=str.replace;s=x(x(s,*".~"),*"\n~")+"~"*w;t=0
while s!=t:t=s;s=[min(s[i+j]for j in n).lower()if"~"==s[i]and(i+1)%w else s[i]for i in r]+["~"]*w
print(x("".join(s[i]if any(s[i]!=s[i+j].lower()!="~"for j in n)else"."for i in r),*"~\n"))
```
There are three parts, each of which needs to be on its own line due to Python's syntax:
1. The first line sets up the variables. `w` is the width of a row of the board (including the newline at the end, which will be recycled as a padding column). `r` is a `range` object that indexes all the characters in `s`. `n` is a tuple of index offsets to get at the neighbors of a character (so if you wanted to allow the letters to spread out diagonally, you'd just need to add `-w-1,-w+1,w-1,w+1` to the tuple). `x` is a short name for the `str.replace` method, which gets used several times in the later code (the calls will look odd though, since I use `x(s,*"xy")` to save characters, rather than the conventional `s.replace("x", "y")`). The `s` parameter string is modified slightly at this point as well, with its `.` characters and newlines being replaced by `~` characters (because they sort after all letters). A row's worth of padding `~` characters are also added to the end. `t` will later be used as a reference to the "old" version of `s`, but it needs to be initialized to something not equal to `s` at the start, and zero takes only one character (a more Pythonic value would be `None`, but that's three extra characters).
2. The second line has a loop that repeatedly updates `s` using a list comprehension. As the comprehension iterates over the indexes of `s`, `~` characters are replaced by the `min` of their neighbors. If a `~` character was completely surrounded by other `~`s, this will do nothing. If it was next to one or more letters, it will become the smallest of them (favoring `"a"` over `"b"`, etc.). The newlines that were turned to `~` characters are preserved by detecting their indexes with the modulus operator. The padding row at the end isn't updated in the list comprehension (because the range of indexes, `r`, was calculated before they were added to `s`). Instead, a fresh row of `~` characters is added after the comprehension is done. Note that `s` becomes a list of characters rather than a string after first pass of the loop (but because Python is flexible about types we can still index to get at the characters in the same way).
3. The last line hollows out the insides of the diagram and rebuilds the characters into a string to be printed. First, any letter that is surrounded only by other copies of itself (or `~` characters from the padding) gets replaced by `.`. Next, the characters are all concatenated together into a single string. Finally, the padding `~` characters are converted back to newlines and the string is printed.
[Answer]
### GolfScript, 138 144 137 characters
```
:^n%,,{{^n/1$=2$>1<.'.'={;{@~@+@@+\{^3$?^<n/),\,@-abs@@-abs+99*+}++^'.
'-\$1<{32+}%}++[0..1.0..(.0]2/%..&,(\0='.'if}{@@;;}if}+^n?,%puts}/
```
Input is given to the subprogram as a single string on the stack. Unfortunately I had to use a `puts` because of the requirement that the routine has to print the result.
**Explanation of the code**
The outer block essentially loops over all position (x,y) according to the size of the input rectangles. Within the loop the coordinates x and y are left on the stack each time. After each line is complete the result is printed to console.
```
:^ # save input in variable ^
n%,,{{ # split along newlines, count rows, make list [0..rows-1]
??? # loop code, see below
}+^n?,%puts}/ # ^n?, count columns, make list [0..cols-1], loop and print
```
The code executed within the loop first takes the corresponding character of the input.
```
^n/ # split input into lines
1$= # select the corresponding row
2$>1< # select the corresponding col
```
Then basically we check, if we have a `.`, i.e. if we (possibly) have to replace the character.
```
.'.'={ # if the character is '.'
; # throw away the '.'
??? # perform more code (see below)
}{ # else
@@;; # remove coordinates, i.e. keep the current character
# (i.e. A, B, ... or \n)
}if # end if
```
Again, the inner code starts with a loop, now over all coordinates (x,y) (x,y+1) (x+1,y) (x,y-1) (x-1,y)
```
{
@~@+@@+\ # build coordinates x+dx, y+dy
??? # loop code
}++ # push coordinates before executing loop code
[0..1.0..(.0]2/% # loop over the coordinates [0 0] [0 1] [1 0] [0 -1] [-1 0]
```
The recent inner code snippet simply returns the (lower case) letter of the nearest point, given the two coordinates.
```
{ # loop
^3$?^< # find the current letter (A, B, ...) in the input string,
# take anything before
n/ # split at newlines
), # from the last part take the length (i.e. column in which the letter is)
\, # count the number of lines remaining (i.e. row in which the letter is)
@-abs@@-abs+ # calculate distance to the given coordinate x, y
99*+ # multiply by 99 and add character value (used for sorting
# chars with equal distance)
}++ # push the coordinates x, y
^'.
'- # remove '.' and newline
\$ # now sort according to the code block above (i.e. by distance to letter)
1<{32+}% # take the first one and make lowercase
```
So from the five nearest letters for the coordinates (x,y) (x,y+1) (x+1,y) (x,y-1) (x-1,y) take the first, if not all are equal, otherwise take a `.`.
```
. # copy five letter string
.&,( # are there distinct letters?
\0= # first letter (i.e. nearest for coordinate x,y)
'.' # or dot
if # if command
```
[Answer]
## Python, 229 226 chars
```
def F(s):
e,f,b='~.\n';N=s.index(b)+1;s=s.replace(f,e)
for i in 2*N*e:s=''.join(min([x[0]]+[[y.lower()for y in x if y>b],all(y.lower()in f+b+x[0]for y in x)*[f]][x[0]!=e])for x in zip(s,s[1:]+b,s[N:]+b*N,b+s,b*N+s))
print s
F("""......B..
.........
...A.....
.........
.......D.
.........
.C.......
.....E...
.........
""")
```
Does a flood fill to compute the result. The trailing `for`/`zip` combo generates an array `x` for each cell containing the value in that cell and its four neighbors. Then we use Blckknght's trick and `min` a bunch of possibilities for each cell. Those are the original cell value, any neighbors if the cell has not been visited yet, or a `.` if it has been visited and all neighbors are `.` or equal to the cell itself.
] |
[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/6284/edit).
Closed 6 years ago.
[Improve this question](/posts/6284/edit)
Back when I was a freshman in highschool taking chemistry, I'd look at the periodic table of elements and spell dirty words out with the number of the elements (HeCK would be 2619, 2-6-19).
I was thinking about this the other day when I saw an amazing shirt that spelled out BeEr (4-68)
So my codegolf challenge is shortest program to output a list of words you can spell with the periodic table of elements AND the number code that would represent that word.
/usr/share/dict/words or whatever dictionary you want to use for the word list. If you're using a "non-standard" word list, let us know what it is!
[Answer]
## GolfScript (339 303 302 301 294 chars)
```
n/{{{32|}%}:L~['']{{`{\+}+'HHeLiBeBCNOFNeNaMgAl
PSClArKCa TiVCrMnFe
ZnGaGeAsSeBrKrRbSrYZr
MoTcRuRhPdAgCd
TeIXe
BaLaCePrNdPmSmEuGdTbDy
ErTm
Lu
TaWRe
IrPtAuHgTl
AtRnFrRaAcThPaU
AmCm
EsFmMd
LrRfDbSg
MtDsRg
UutFl
Lv'{[1/{.0=96>{+}*}/]}:S~:^/}%.{L}%2$?.){=S{^?}%`+p 0}{;{L.,2$<=},.}if}do}%;
```
With credit to [PhiNotPi](https://codegolf.stackexchange.com/users/2867/phinotpi) whose observation on unnecessary elements allowed me to save 33 chars.
This is IMO much more idiomatic GolfScript than the previous recursive approach.
Note that I allow words in the dictionary to be mixed case (`L` is a function to lower-case text on the assumption that it doesn't matter if non-alpha characters get broken) but reject any with apostrophes or accents.
Since this is code golf, I've optimised for code length rather than speed. This is horrendously slow. It expects the word list to be supplied at stdin and outputs to stdout in the format:
```
"ac[89]"
"accra[89 6 88]"
"achebe[89 2 4]"
...
```
(lower-casing any mixed-case input words for which it finds a match).
If you're more interested in the elements than the numbers per se, for the low low price of 261 253 chars you can use
```
n/{{{32|}%}:L~['']{{`{\+}+'HHeLiBeBCNOFNeNaMgAlPSClArKCaTiVCrMnFeZnGaGeAsSeBrKrRbSrYZrMoTcRuRhPdAgCdTeIXeBaLaCePrNdPmSmEuGdTbDyErTmLuTaWReIrPtAuHgTlAtRnFrRaAcThPaUAmCmEsFmMdLrRfDbSgMtDsRgUutFlLv'[1/{.0=96>{+}*}/]/}%.{L}%2$?.){=p 0}{;{L.,2$<=},.}if}do}%;
```
which gives output like
```
"Ac"
"AcCRa"
"AcHeBe"
...
```
[Answer]
# Ruby - 547 393
New version, thanks for the suggestions:
```
e='HHeLiBeBCNOFNeNaMgAlSiPSClArKaCaScTiVCrMnFeCoNiCuZnGaGeAsSeBrKrRbSrYZrNbMoTcRuRhPdAgCdInSnSbTeIXeCsBaLaCePrNdPmSmEuGdTbDyHoErTmYbLuHfTaWReOsIrPtAuHgTlPbBiPoAtRnFrRaAcThPaUNpPuAmCmBkCfEsFmMdNoLrRfDbSgBhHsMtDsRgCnUutFlUupLvUusUuo'.scan(/[A-Z][a-z]*/).map &:upcase
r="(#{e.join ?|})"
$<.each{|w|(i=0;i+=1 until w=~/^#{r*i}$/i
$><<w;p$~.to_a[1..-1].map{|m|e.index(m.upcase)+1})if w=~/^#{r}+$/i}
```
---
```
e=%w{h he li be b c n o f ne na mg al si p s cl ar ka ca sc ti v cr mn fe co ni cu zn ga ge as se br kr rb sr y zr nb mo tc ru rh pd ag cd in sn sb te i xe cs ba la ce pr nd pm sm eu gd tb dy ho er tm yb lu hf ta w re os ir pt au hg tl pb bi po at rn fr ra ac th pa u np pu am cm bk cf es fm md no lr rf db sg bh hs mt ds rg cn uut fl uup lv uus uuo}
x = "(#{e.join(?|)})"
regex = /^#{x}+$/i
File.foreach('/usr/share/dict/words'){|w|
if w=~/^#{x}+$/i
puts w
i=1
i+=1 until w=~/^#{x*i}$/i
puts $~[1..-1].map{|m|e.index(m.downcase)+1}.join ?-
end
}
```
uses regexes. slow, and much room for improvement but i must go now :-)
[Answer]
## Python 710 (357 + 261 + 92)
```
e=". h he li be b c n o f ne na mg al si p s cl ar k ca sc ti v cr mn fe co ni cu zn ga ge as se br kr rb sr y zr nb mo tc ru rh pd ag cd in sn sb te i xe cs ba la ce pr nd pm sm eu gd tb dy ho er tm yb lu hf ta w re os ir pt au hg tl pb bi po at rn fr ra ac th pa u np pu am cm bk cf es fm md no lr rf db sg bh hs mt ds rg cn uut fl uup lv uus uuo".split()
i=e.index
def m(w,p=("",[])):
if not w:return p
x,y,z=w[0],w[:2],w[:3]
if x!=y and y in e:
a=m(w[2:],(p[0]+y,p[1]+[i(y)]))
if a:return a
if x in e:
b=m(w[1:],(p[0]+x,p[1]+[i(x)]))
if b:return b
if z in e:
c=m(w[3:],(p[0]+z,p[1]+[i(z)]))
if c:return c
f=open('/usr/share/dict/words','r')
for l in f:
x=m(l[:-1])
if x:print x[0],x[1]
f.close()
```
There's sure to be room for improvement in there somewhere. It's also worth noting that the second level of indentation uses the tab character.
It takes just over 5 seconds (on my computer) to go through the whole dictionary, producing output like this:
```
acaciin [89, 89, 53, 49]
acacin [89, 89, 49]
acalycal [89, 13, 39, 6, 13]
...
```
By adding another **18** characters, you can get output with the right capitalization:
```
e=". H He Li Be B C N O F Ne Na Mg Al Si P S Cl Ar K Ca Sc Ti V Cr Mn Fe Co Ni Cu Zn Ga Ge As Se Br Kr Rb Sr Y Zr Nb Mo Tc Ru Rh Pd Ag Cd In Sn Sb Te I Xe Cs Ba La Ce Pr Nd Pm Sm Eu Gd Tb Dy Ho Er Tm Yb Lu Hf Ta W Re Os Ir Pt Au Hg Tl Pb Bi Po At Rn Fr Ra Ac Th Pa U Np Pu Am Cm Bk Cf Es Fm Md No Lr Rf Db Sg Bh Hs Mt Ds Rg Cn Uut Fl Uup Lv Uus Uuo".split()
i=e.index
def m(w,p=("",[])):
if not w:return p
w=w.capitalize()
x,y,z=w[0],w[:2],w[:3]
if x!=y and y in e:
a=m(w[2:],(p[0]+y,p[1]+[i(y)]))
if a:return a
if x in e:
b=m(w[1:],(p[0]+x,p[1]+[i(x)]))
if b:return b
if z in e:
c=m(w[3:],(p[0]+z,p[1]+[i(z)]))
if c:return c
OUTPUT:
AcAcIIn [89, 89, 53, 49]
AcAcIn [89, 89, 49]
AcAlYCAl [89, 13, 39, 6, 13]
...
```
You can also check individual words:
```
>>> m("beer")
('beer', [4, 68])
```
[Answer]
## Python - 1328 (975 + 285 chars of code + 68 dictionary code)
```
t1={'c':6,'b':5,'f':9,'i':53,'h':1,'k':19,'o':8,'n':7,'p':15,
's':16,'u':92,'w':74,'v':23,'y':39}
t2={'ru':44,'re':75,'rf':104,'rg':111,'ra':88,'rb':37,
'rn':86,'rh':45,'be':4,'ba':56,'bh':107,'bi':83,
'bk':97,'br':35,'os':76,'ge':32,'gd':64,'ga':31,
'pr':59,'pt':78,'pu':94,'pb':82,'pa':91,'pd':46,
'cd':48,'po':84,'pm':61,'hs':108,'ho':67,'hf':72,
'hg':80,'he':2,'md':101,'mg':12,'mo':42,'mn':25,
'mt':109,'zn':30,'eu':63,'es':99,'er':68,'ni':28,
'no':102,'na':11,'nb':41,'nd':60,'ne':10,'np':93,
'fr':87,'fe':26,'fl':114,'fm':100,'sr':38,'kr':36,
'si':14,'sn':50,'sm':62,'sc':21,'sb':51,'sg':106,
'se':34,'co':27,'cn':112,'cm':96,'cl':17,'ca':20,
'cf':98,'ce':58,'xe':54,'lu':71,'cs':55,'cr':24,
'cu':29,'la':57,'li':3,'lv':116,'tl':81,'tm':69,
'lr':103,'th':90,'ti':22,'te':52,'tb':65,'tc':43,
'ta':73,'yb':70,'db':105,'dy':66,'ds':110,'at':85,
'ac':89,'ag':47,'ir':77,'am':95,'al':13,'as':33,
'ar':18,'au':79,'zr':40,'in':49}
t3={'uut':113,'uuo':118,'uup':115,'uus':117}
def p(s):
o=0;b=0;a=[];S=str;l=S.lower;h=dict.has_key;L=len
while o<L(s):
D=0
for i in 1,2,3:exec('if h(t%d,l(s[o:o+%d])) and b<%d:a+=[S(t%d[s[o:o+%d]])];o+=%d;b=0;D=1'%(i,i,i,i,i,i))
if D==0:
if b==3 or L(a)==0:return
else:b=L(S(a[-1]));o-=b;a.pop()
return '-'.join(a)
```
For the dictionary part:
```
f=open(input(),'r')
for i in f.readlines():print p(i[:-1])
f.close()
```
[Answer]
## C, 775 771 chars
```
char*e[]={"h","he","li","be","b","c","n","o","f","ne","na","mg","al","si","p","s","cl","ar","k","ca","sc","ti","v","cr","mn","fe","co","ni","cu","zn","ga","ge","as","se","br","kr","rb","sr","y","zr","nb","mo","tc","ru","rh","pd","ag","cd","in","sn","sb","te","i","xe","cs","ba","la","ce","pr","nd","pm","sm","eu","gd","tb","dy","ho","er","tm","yb","lu","hf","ta","w","re","os","ir","pt","au","hg","tl","pb","bi","po","at","rn","fr","ra","ac","th","pa","u","np","pu","am","cm","bk","cf","es","fm","md","no","lr","rf","db","sg","bh","hs","mt","ds","rg","cn","uut","fl","uup","lv","uus","uu",0};
b[99],n;
c(w,o,l)char*w,*o,**l;{
return!*w||!strncmp(*l,w,n=strlen(*l))&&c(w+n,o+sprintf(o,",%d",l-e+1),e)||*++l&&c(w,o,l);
}
main(){
while(gets(b))c(b,b+9,e)&&printf("%s%s\n",b,b+9);
}
```
**Input**: Word per line, must be lowercase. `usr/share/dict/words` is fine.
**Output**: Word and numbers, e.g.: `acceptances,89,58,15,73,7,6,99`
**Logic**:
`c(w,o,l)` checks the word `w`, starting with element `l`.
Two-way recursion is used - if the first element matches the head of the element list, check the remainer of `w` against the full element list. If this match fails, check the word against the tail of the list.
The buffer `o` accumulates the element numbers along the successful path. After a match, it will contain the list of numbers, and is printed.
**Issues**:
The list isn't encoded efficiently - too much `"` and `,`". But this way it's easy to use. I'm sure it can be much improved, without too much cost in code.
] |
[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/61922/edit).
Closed 8 years ago.
[Improve this question](/posts/61922/edit)
## Question
>
> If you are currently on a cell with a value x, you can move to any
> cell in the same row or column, provided it has a value y such that x >
> y. This move is called a **switch**.
>
>
>
The **input** consists of:
* two integers 0 < m,n < 50
* an integer k indicating the number of switches allowed 0 < k < 20
* an m by n grid filled with integers in the range -128 to 127
The **output** consists of:
* a single integer r, indicating the minimum number of cells that have to be coloured red to satisfy the condition.
The **condition** is that:
* if any cell is selected on the switchboard, it must be possible to
+ start at any red cell of your choice
+ make upto k switches
+ end up at the selected cell
* the output must be reached within **60 seconds** using any amount of memory.
## Sample data
**Inputs**
```
(a) 7 8 10
55 25 49 40 55 3 55
33 32 26 59 41 40 55
31 23 41 58 59 14 33
9 19 9 40 4 40 40
55 54 55 46 52 39 41
10 41 7 47 5 30 54
40 22 31 36 7 40 28
21 40 41 59 14 36 31
(b) 9 8 10
50 98 54 6 34 94 63 52 39
62 46 75 28 65 18 37 18 97
13 80 33 69 93 78 19 40 13
94 10 88 43 61 72 94 94 94
41 79 82 27 71 62 57 67 34
8 93 2 12 93 52 91 86 93
94 79 64 43 32 94 42 91 9
25 73 29 31 19 70 58 12 11
(c) 10 9 10
50 54 6 34 78 63 52 39 41 46
75 28 65 18 37 18 13 80 33 69
78 19 40 13 10 43 61 72 13 46
56 41 79 82 27 71 62 57 67 81
8 71 2 12 52 81 1 79 64 81
32 41 9 25 73 29 31 19 41 58
12 11 41 66 63 14 39 71 38 16
71 43 70 27 78 71 76 37 57 12
77 50 41 81 31 38 24 25 24 81
```
**Outputs**
```
(a) 9
(b) 9
(c) 8
```
## Winning
You may use any language. Shortest code wins.
]
|
[Question]
[
In this task you have to write a program that reads a regular expression and generates another program that outputs whether an input string is accepted by that regular expression. The output must be a program written in the same language as your submission.
# Input
The input is a regular expression *r* matching the following ABNF (the initial production rule is `REGEX`):
```
REGEX = *( STAR / GROUP / LITERAL / ALTERNATIVE )
STAR = REGEX '*'
GROUP = '(' REGEX ')'
LITERAL = ALPHA / DIGIT
ALTERNATIVE = REGEX '|' REGEX
```
If the input does not match this grammar, the behavior of your program is undefined.
# Interpretation
Interprete the input as a regular expression, where `*` is the Kleene-star (meaning *repeat left argument zero or more times*), `|` is an alternative, `(` and `)` group and no operator at all concatenated. Grouping takes precedence over star, star takes precedence over concatenation, concatenation takes precedence over alternative.
A string is said to be *accepted* if the regex matches the whole string.
# Output
The program's output is another program written in the same language as your submission that reads a string *s* in an implementation defined way at runtime, outputs whether *r* accepts *s* and then terminates. Output may be done in a user-defined way although there must be only two distinct outputs for accepted and rejected programs.
You may assume that the input of your output program is never longer than 216-1 Bytes.
# Restrictions
Neither your submission nor any program generated by your submission may use builtin functionality or libraries that
* match regexes
* transform regular expressions
* compile regular expressions
* generate parsers from a grammar
* simplify the problem in a way that your submission becomes trivial
# Scoring
The score of your submission is the number of characters it. The submission with the lowest score wins.
# Testcases
All testcases contain a regular expression, a set of accepted strings, a set of rejected strings and an example program in C99 which is a valid output of a (hyptothetical) C99 submission.
## (empty regular expression)
### Accepted strings
1. (empty input)
### Rejected strings
1. foo
2. bar
3. baz
4. quux
### Example program
```
#include <stdio.h>
int main() {
char input[65536];
gets(input);
return input[0] != 0;
}
```
## `(b|)(ab)*(a|)` (`a` and `b` alternating)
### accepted strings
1. `a`
2. `ba`
3. `abababababa`
4. `abab`
### rejected strings
1. `afba`
2. `foo`
3. `babba`
### example program
```
#include <stdio.h>
int main() {
char input[65536];
int state = 0;
for (;;) switch (state) {
case 0: switch (getchar()) {
case 'a': state = 1; break;
case 'b': state = 2; break;
case EOF: return 0;
default: return 1;
} break;
case 1: switch (getchar()) {
case 'b': state = 2; break;
case EOF: return 0;
default: return 1;
} break;
case 2: switch (getchar()) {
case 'a': state = 1; break;
case EOF: return 0;
default: return 1;
} break;
}
```
## `(0|1(0|1)*)(|A(0|1)*1)` (binary floating point numbers)
### accepted strings
1. 10110100
2. 0
3. 1A00001
### rejected strings
1. 011
2. 10A
3. 1A00
4. 100A010
[Answer]
## C, 627 characters
This program treats its first command-line argument as the input and generates C code as its output.
```
#define A(v) F[v]+strlen(F[v])
#define S sprintf
char*B="&&f%d(s)||f%d(s)",*J="&&f%d(s+%d)",*r,F[256][65536];h=2;e(f,n,o,R,C,O,t,g){for(C=O=f;*r;++r)switch(*r){case 40:r++;e(g=h++,C=h++,0,0);r[1]^42?t=g:(t=C,S(A(t),B,g,C=h++),r++);o=!S(A(O),J,t,o);O=C;break;case 41:goto L;case'|':S(A(C),J,n,o);o=!S(A(O=f),"||1");break;default:r[1]^42?S(A(C),"&&s[%d]==%d",o++,*r,O^f||R++):(o=!S(A(O),J,t=h++,o),O=C=h++,g=h++,S(A(g),"&&*s==%d&&f%d(s+1)",*r++,t),S(A(t),B,g,C));}L:S(A(C),J,n,o);}main(int c,char**v){r=v[1];for(e(1,!S(*F,"&&!*s"),0,0);h--;)printf("f%d(char*s){return 1%s;}",h,F[h]);puts("main(int c,char**v){exit(f1(v[1]));}");}
```
Here is its output for `(0|1(0|1)*)(|A(0|1)*1)` (with newlines added):
```
f11(char*s){return 1&&s[0]==49&&f7(s+1);}
f10(char*s){return 1&&s[0]==48&&f9(s+1)||1&&s[0]==49&&f9(s+1);}
f9(char*s){return 1&&f10(s)||f11(s);}
f8(char*s){return 1&&f7(s+0)||1&&s[0]==65&&f9(s+1);}
f7(char*s){return 1&&f0(s+0);}
f6(char*s){return 1&&f2(s+0);}
f5(char*s){return 1&&s[0]==48&&f4(s+1)||1&&s[0]==49&&f4(s+1);}
f4(char*s){return 1&&f5(s)||f6(s);}
f3(char*s){return 1&&s[0]==48&&f2(s+1)||1&&s[0]==49&&f4(s+1);}
f2(char*s){return 1&&f8(s+0);}
f1(char*s){return 1&&f3(s+0);}
f0(char*s){return 1&&!*s;}
main(int c,char**v){exit(f1(v[1]));}
```
If you provide valid input as its first command-line argument, it returns exit status 1. Otherwise, it returns exit status 0.
>
> $ ./regexcompiler '(0|1(0|1)\*)(|A(0|1)\*1)' > floatprog.c
>
> $ gcc -o floatprog floatprog.c
>
> floatprog.c: In function ‘main’:
>
> floatprog.c:1:519: warning: incompatible implicit declaration of built-in function ‘exit’ [enabled by default]
>
> $ ./floatprog '1A00001' && echo invalid || echo valid
>
> valid
>
> $ ./floatprog '100A010' && echo invalid || echo valid
>
> invalid
>
>
>
Either program, if you fail to provide the command-line argument, dereferences a null pointer, causing a segmentation fault. A sufficiently long regex will overflow the buffers of this submission, and the size of input to a generated program is limited by the size of the stack. However, all the test cases work.
Note that `e(g=h++,C=h++,0,0);` introduces undefined behavior. If, for example, generated programs do not compile, you can try replacing the statement with `h+=2;e(g=h-1,C=h-2,0,0);`, which is five characters longer.
[Answer]
### Ruby, 641 651 543 characters
```
H=Hash.new{|h,k|[k]}
d=[[i=0,0,[]]]
o=[?(]
L="t,u,v=d.pop;q,r,s=d.pop;o.pop<?|&&(H[r]<<=t)||(H[q]<<=t;H[r]<<=u);d<<[q,u,s+v]"
gets.chop.chars.map{|c|c==?*&&(q,r,s=d.pop;H[r]|=[q,i+=1];d<<=[r,i,s];next)
eval(L)while/[|)]/=~c ?o[-1]>?(:o[-1]==?.
/[|(]/=~c&&d<<[i+=1,i,o<<c&&[]]||c!=?)&&d<<[i+=1,i+1,["s==#{o<<?.;i}&&c=='#{c}'&&#{i+=1}"]]||o[-1]=?.}
eval(L)while o.size>1
H.map{H.map{|k,v|v.map{|v|H[k]|=H[v]}}}
t,u,v=d[0]
$><<"s=#{H[t]};gets.chop.chars.map{|c|s=s.map{|s|#{v*'||'}}-[!0];#{H.map{|k,v|"s&[#{k}]!=[]&&s|=#{v}"}*?;}};p s&[#{u}]!=[]"
```
This ruby version became quite long because of several corner cases in the regex parser (maybe I should try a different approach). It expects the regular expression on STDIN and outputs the corresponding ruby code for the matcher to STDOUT.
The program directly generates code for a [NFA-ε](http://en.wikipedia.org/wiki/Nondeterministic_finite_automaton_with_%CE%B5-moves) which is then executed in the matcher.
**Test case 1:**
*(output includes additional newlines and indentation)*
```
>>>
s=[0];
gets.chop.chars.map{|c|
s=s.map{|s|}-[!0];
};
p s&[0]!=[]
```
**Test case 2:**
```
>>> (b|)(ab)*(a|)
s=[0, 1, 2, 4, 9, 5, 10, 6, 11, 12, 14];
gets.chop.chars.map{|c|
s=s.map{|s|s==2&&c=='b'&&3||s==6&&c=='a'&&7||s==8&&c=='b'&&9||s==12&&c=='a'&&13}-[!0];
s&[1]!=[]&&s|=[1, 2, 4, 9, 5, 10, 6, 11, 12, 14];
s&[3]!=[]&&s|=[3, 4, 9, 5, 10, 6, 11, 12, 14];
s&[0]!=[]&&s|=[0, 1, 2, 4, 9, 5, 10, 6, 11, 12, 14];
s&[5]!=[]&&s|=[5, 6];
s&[7]!=[]&&s|=[7, 8];
s&[9]!=[]&&s|=[9, 5, 10, 6, 11, 12, 14];
s&[4]!=[]&&s|=[4, 9, 5, 10, 6, 11, 12, 14];
s&[11]!=[]&&s|=[11, 12, 14];
s&[13]!=[]&&s|=[13, 14];
s&[10]!=[]&&s|=[10, 11, 12, 14]
};
p s&[14]!=[]
```
**Another example:**
```
>>> a|bc
s=[0, 1, 3, 4];
gets.chop.chars.map{|c|
s=s.map{|s|s==1&&c=='a'&&2||s==4&&c=='b'&&5||s==6&&c=='c'&&7}-[!0];
s&[0]!=[]&&s|=[0, 1, 3, 4];
s&[3]!=[]&&s|=[3, 4];
s&[5]!=[]&&s|=[5, 6];
s&[2]!=[]&&s|=[2, 7]
};
p s&[7]!=[]
```
*Edit:* Added a transition to fix the bug [PleaseStand](https://codegolf.stackexchange.com/users/163/pleasestand) noted in the comments. Also changed initialisation of state.
] |
[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/61144/edit).
Closed 8 years ago.
[Improve this question](/posts/61144/edit)
**The Challenge**
A bubble sort takes a list of non-repeating integers and sorts them in ascending order, with only the use of one operation: switching two numbers which are next to eachother.
However for this puzzle, you must take in two strings, which are both anagrams, and bubble sort the letters of the first string into the second.
**Example:**
Trap, Part
TRAP
TRPA
TPRA
PTRA
PTAR
PATR
PART
**Rules**
* Your program must only use the switching operation
* Your program must use the most optimal way of bubble sorting
* This is code golf, lowest amount of bytes wins!
]
|
[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/59870/edit).
Closed 8 years ago.
[Improve this question](/posts/59870/edit)
Quines have been around forever. It's a fun challenge: write a program that, when executed, generates its own source code as output. But how do you know it's actually producing its own source code? Generally, you have to look at it and compare it, but with quines generally being composed of tricky and intricate code, this is not always easy.
Comparing two strings, though, is something a computer does very well, so why not make the program validate itself? Your task is to create a program that:
* produces its own source code as output
* compares its output to its own source code
* raises some sort of error, appropriate to the language used, if the output does not match
+ If the output does match, it's acceptable to terminate without further output
+ it can be hard-coded to know where to look to find its own source code for purposes of comparison. Using this knowledge to actually produce the output in the first place, however, is cheating.
Popularity contest; whoever gets the most upvotes wins. No standard loopholes, etc, you know the drill.
Enjoy!
]
|
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
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).
Closed 8 years ago.
[Improve this question](/posts/55076/edit)
I encountered this question in an interview and could not figure it out. I believe it has a dynamic programming solution but it eludes me.
Given a number of bricks, output the total number of 2d pyramids possible, where a pyramid is defined as any structure where a row of bricks has strictly less bricks than the row below it. You do not have to use all the bricks.
It makes sense to just add P(1) + ... + P(n), but how to find all possible pyramids with 1 < i <= n bricks?
Code length is not as important as the solution itself, but go ahead and have fun with it?
]
|
[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/49955/edit).
Closed 8 years ago.
[Improve this question](/posts/49955/edit)
Given a positive integer, `n`, along with `n` non-negative integers, write a program or function that prints or returns the smallest non-negative integer that can be obtained by additions and subtractions between those numbers. You must use all of the input numbers.
The winner is the algorithm with the smallest big O time complexity. Ties will be broken by shortest code, in bytes. Please post your time complexity and your byte count along with your submission.
**Examples**
Input: `5` `14 16 20 10 2`
Output: `2`
Two is the smallest number that can be obtained by adding or subtracting the given numbers, as shown by `16 + 14 - 20 - 10 + 2 = 2`.
Input: `4` `1 1 1 1`
Output: `0`
Input: `1` `0`
Output: `0`
Input: `3` `100 50 49`
Output: `1`
]
|
[Question]
[
**This question already has answers here**:
[Four Squares Together](/questions/28169/four-squares-together)
(16 answers)
Closed 8 years ago.
## Sum of squares
Goal: Write a given natural number as sum of squares. Thanks to Lagrange, Fermat and Legendre we know that you can write any positive integer as sum of (one), two, three, or maximal four squares of integers.
Your task is to write a program/function which takes a natural number via stdin/argument and outputs/returns a list of one to four numbers, where the sum of the squares of those numbers equals the input number. But you have to find the shortest possible example, that means if you can write a number as three squares, you may not output the four squares version.
Examples:
```
1 : 1
2 : 1,1
3 : 1,1,1
4 : 2
5 : 1,2
6 : 1,1,2
127 : 1,3,6,9
163 : 1,9,9
1234 : 3,35
1248 : 8,20,28
```
[Answer]
# JavaScript: 141
```
function x(i){var a=0,b,c,d;for(;a<i;a++)for(b=0;b<i;b++)for(c=0;c<i;c++)for(d=0;d<i;d++)if(a*a+b*b+c*c+d*d==i){console.log(a,b,c,d);return}}
```
] |
[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/48293/edit).
Closed 8 years ago.
[Improve this question](/posts/48293/edit)
Given string X, convert it to Java Style string, as defined below:
* Strings may only contain numbers and letters(signs are not allowed)
* Strings must not start with numbers
* Strings must start with Capital letter
* Strings may not contain two capital letters in a raw.
As for conversion you may perform the next actions
* Replace capital letter with lower case letter and vise versa.
* Remove character
A good conversion is defined as follow:
Minimum actions been performed while achieving the next goals:
* all the sequences of capital letters only kept the first letter as capital.
* if a letter has a character in place before it, and the character is not a letter nor a number, then the letter becomes capital.
* in case that after a good conversion there is a contradiction with the style, good conversion will be applied again on the result of previous conversion.
* If there is more then one way to apply good conversion, than conversion `A` is considered to be better then conversion `B` if conversion `A` has more capital letters then `B`.
**Input:**
* String x
**Output:**
* Best conversion Java Style String
**I/O examples**
```
X Output
'ab<>c' 'AbC'
'a<>b<>c' 'Abc' // conversion been applied twice. ABC -> Abc
'a<>bc' 'Abc' // conversion been applied twice. ABc -> Abc
'HI<>man' 'HiMan'
'' ''
'its**cOOL' 'ItsCool'
'28and*2fun' 'And2fun' // conversion been applied twice. and2fun -> And2fun
```
In this example strings been wrapped with '' sign.
**Criteria**
* The shortest program wins, as determined by the number of bytes of source code.
[Answer]
# Java ~~551~~ 490 bytes
```
public class A{public static void main(String...a){String b="";for(int i=0;i<2;i++){String[]c=a[0].split("[^a-zA-Z0-9]");if(c[0].length()>0&&Character.isDigit(c[0].charAt(0)))c[0]=c[0].replaceFirst("[0-9]+","");b="";for(String d:c){boolean e=false;String f="";byte[]g=d.getBytes();for(byte h:g){if(e){if(Character.isLowerCase(h))e=false;else h+='a'-'A';}else if(!Character.isLowerCase(h))e=true;f+=(char)h;}d=f;if(d.length()>0)b+=StringUtils.capitalize(d);}a[0]=b;}System.out.println(b);}}
```
Ungolfed Code:
```
public class A{
public static void main(String...args){
String input = args[0];
String className = "";
for (int i = 0; i < 2; i++) {
String[] names = input.split("[^a-zA-Z0-9]");
if(names[0].length() > 0 && Character.isDigit(names[0].charAt(0))){
names[0] = names[0].replaceFirst("[0-9]+", "");
}
className = "";
for (String value : names) {
boolean toLowerCase = false;
String newValue = "";
byte[] bytes = value.getBytes();
for (byte aByte : bytes) {
if(toLowerCase){
if (Character.isLowerCase(aByte)){
toLowerCase = false;
}
else{
aByte += 'a' - 'A';
}
}
else if (!Character.isLowerCase(aByte)){
toLowerCase = true;
}
newValue += (char)aByte;
}
value = newValue;
if(value.length() > 0){
className += StringUtils.capitalize(value);
}
}
input = className;
}
System.out.println(className);
}
}
```
[Answer]
## Haskell 316 bytes
Not fully golfed, may spend time to golf a bit more if others come and join the game.
```
import Data.Char
data T = C | S | X
conv t [] = []
conv t (c:cs)
|isLower c = case t of X -> toUpper c : conv C cs; _ -> c : conv S cs
|isUpper c = case t of C -> toLower c : conv X cs; _ -> c : conv C cs
|isDigit c = c : conv S cs
|otherwise = conv X cs
main = interact $ conv X . dropWhile isDigit . conv X
```
The C, S, X, `data = T = C | S | X` stands for Capital, Small, Other.
] |
[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/47439/edit).
Closed 8 years ago.
[Improve this question](/posts/47439/edit)
You can find the Hack Assembly Language specification here: <http://www.cs.huji.ac.il/course/2002/nand2tet/docs/ch_4_machine_language.pdf>
You can download the Hack Computer emulator here:
<http://www.nand2tetris.org/software.php>
The goal is to write something similar to this:
```
int i = 1;
while(i<100){
i = i+i;
}
```
My solution is here:
```
@17 // Set Register A to 17
M = 1 // Set M[17] = 1
@17 // Set Register A to 17 --> This is location 2 btw
D = M // Set Register D to value stored in M[17]
A = D // Copy the value found in Register D to A
D = D+A // Set value in D = D + A
@17 // Set Register A to 17
M = D // Store the value in M[17] to the value of Register D
@100 // Store value 100 in Register A
D = D-A // Set value in D to D - 100
@2 // Set Register A to 2
D;JLT // If D<0 D is still not greater than 100. Goto location 2
```
Can you come up with something shorter?
]
|
[Question]
[
The [Vigenère cipher](http://en.wikipedia.org/wiki/Vigen%C3%A8re_cipher) was a simple polyalphabetic cipher that basically applied one of several Caesar ciphers, according to a key. Basically the letters in the key indicate which shifted alphabet to use. To that end there was a simple tool, called the *Vigenère square:*
[](http://en.wikipedia.org/wiki/File:Vigen%C3%A8re_square.svg)
Here each row is a separate alphabet, starting with the corresponding letter of the key. The columns then are used to determine the ciphered letter. Decryption works in very much the same fashion, only vice-versa.
Suppose we want to encrypt the string `CODEGOLF`. We also need a key. In this case the key shall be `FOOBAR`. When the key is shorter than the plaintext we extend it by repetition, therefore the actual key we use is `FOOBARFO`. We now look up the first letter of the key, which is `F` to find the alphabet. It starts, perhaps unsurprisingly, with `F`. Now we find the column with the first letter of the plaintext and the resulting letter is `H`. For the second letter we have `O` as the key letter and the plain text letter, resulting in `C`. Continuing that way we finally get `HCRFGFQT`.
**Task**
Your task now is to decipher messages, given a key. However, since we have outgrown the 16th century and have computers we should at least support a slightly larger alphabet:
```
abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789
```
The construction of the Vigenère square is still very much the same and the cipher still works in the same way. It's just a bit ... unwieldy to give here in full.
**Input**
Input is given on standard input as two separate lines of text, each terminated by a line break. The first line contains the key while the second contains the ciphertext.
**Output**
A single line, containing the deciphered message.
**Winning condition**
Since encryption is sometimes regarded as a weapon, the code should be short to facilitate easy smuggling. The shorter the better, as it reduces the likelihood of discovery.
**Sample input 1**
```
Key
miQ2eEO
```
**Sample output 1**
```
Message
```
**Sample input 2**
```
ThisIsAKey
CoqKuGRUw29BiDTQmOpJFpBzlMMLiPb8alGruFbu
```
**Sample output 2**
```
ThisWorksEquallyWellWithNumbers123894576
```
A week has passed. The currently shortest solution has been accepted. For those interested, in our contest we had the following submissions and lengths:
>
> 130 – Python
>
> 146 – Haskell
>
> 195 – C
>
> 197 – C
>
> 267 – VB.NET
>
>
>
And our own solutions that weren't ranked with the others:
>
> 108 – Ruby
>
> 139 – PowerShell
>
>
>
[Answer]
## Golfscript -- 48 chars
```
n%~.,@*\{\(123,97>91,65>+58,48>+:|?@|?\-|=}%\0<+
```
No tricks in this one!
[Answer]
## MS-DOS 16bit .COM file - 87 bytes
Base64 encoded binary ([following this link for a decoder](http://www.motobit.com/util/base64-decoder-encoder.asp))
```
v1cBi8/oQACJ/ovv6DkAi9msitAqF3MDgMI+gMJhgPp6dguA6jqA+lp2A4DqK80hO/d0IkM563TW69YsYXMIBCB9AgQrBBqqtAHNITwNdev+xLIKzSHD
```
[Answer]
## APL (45)
```
∆[⍙⍳⍨¨⌽∘∆¨(⍴⍙←⍞)⍴1-⍨⍞⍳⍨∆←⎕D,⍨⎕A,⍨⎕UCS 96+⍳26]
```
Explanation:
* `∆←⎕D,⍨⎕A,⍨⎕UCS 96+⍳26`: generate the alphabet (numbers (`⎕D`) follow letters (`⎕A`) follow lowercase letters (`⎕UCS 96+⍳26`, the unicode values from 97 to 122).
* `1-⍨⍞⍳⍨∆`: read a line (the key), find the position of each character in the alphabet, and subtract one (arrays are one-based by default, so shifting by those values directly would shift the alphabet one too far).
* `(⍴⍙←⍞)⍴`: read another line (the message), and repeat the indices of the key so that it has the length of the message.
* `⌽∘∆¨`: rotate the alphabet by the indices belonging to the key
* `⍙⍳⍨¨`: look up each character in the message in the corresponding shifted alphabet
* `∆[`...`]`: look up the given indices in the normal alphabet, giving the corresponding characters.
[Answer]
## Ruby - 132 127 122 109 100 characters
```
a,b=*$<
c=*?a..?z,*?A..?Z,*?0..?9
(b.size-1).times{|i|$><<c[c.index(b[i])-c.index(a[i%(a.size-1)])]}
```
[Answer]
## Python - 122 chars
```
from string import*
L=letters+digits
R=raw_input
K,T=R(),R()
F=L.find
print"".join(L[F(i)-F(j)]for i,j in zip(T,K*len(T)))
```
[Answer]
## J, 65 characters
```
v=:4 : 'a{~x(62|[:-/"1 a i.[,.#@[$])y[a=.a.{~62{.;97 65 48+/i.26'
```
Doesn't completely meet the spec since it's defined as a verb rather than taking input, but I'm posting it anyway with the intention of fiddling with it at a later date.
Usage:
```
'miQ2eEO' v 'Key'
Message
'CoqKuGRUw29BiDTQmOpJFpBzlMMLiPb8alGruFbu' v 'ThisIsAKey'
ThisWorksEquallyWellWithNumbers123894576
```
[Answer]
## Perl, 95 chars
Perl 5.010, run with `perl -E`:
```
%a=map{$_,$n++}@a=(a..z,A..Z,0..9);@k=<>=~/./g;
$_=<>;s/./$a[($a{$&}-$a{$k[$i++%@k]})%62]/ge;say
```
[Answer]
## Python - ~~144~~ ~~143~~ ~~140~~ ~~136~~ 125 characters
Probably not the best, but hey:
```
from string import*
l=letters+digits
r=l.find
q=raw_input
k=q()
print"".join(l[(r(j)-r(k[i%len(k)]))%62]for i,j in enumerate(q()))
```
[Answer]
## Golfscript - 65 chars
Still needs to be golfed more. For now, T is the text, K is the Key, L is the list of letters
```
n%):T,\~*:K;''26,{97+}%+.{32^}%10,{48+}%++:L;T{L\?K(L\?\:K;-L\=}%
```
[Answer]
## K,81 61
```
k:0:0;,/$(m!+(`$'m)!+{(1_x),1#x}\m:,/.Q`a`A`n)[(#v)#k]?'v:0:0
```
.
```
k)k:0:0;,/$(m!+(`$'m)!+{(1_x),1#x}\m:,/.Q`a`A`n)[(#v)#k]?'v:0:0
ThisIsAKey
CoqKuGRUw29BiDTQmOpJFpBzlMMLiPb8alGruFbu
"ThisWorksEquallyWellWithNumbers123894576"
```
[Answer]
## Perl, 115 chars
```
$a=join'',@A=(a..z,A..Z,0..9);$_=<>;chop;@K=split//;$_=<>;s/./$A[(index($a,$&)-index($a,$K[$-[0]%@K]))%@A]/ge;print
```
[Answer]
## Golfscript - 92 characters
```
n%~\.,:l;{0\{1$+\)\}%\;}:&;26'a'*&26'A'*&+10'0'*&+\@.,,{.l%3$=4$?\2$=4$?\- 62%3$\>1<}%\;\;\;
```
Probably much longer than it needs to be. Still trying to get my head around GS.
Heres the "ungolfed" and commented version
```
n%~\.,:l;
{0\{1$+\)\}%\;}:&; # This would be sortof an equivalent for range applied to strings
26'a'*&26'A'*&+10'0'*&+\@., # This mess generates the dictionary string,
# l = len(key)
# 0 dictionary (letters + digits)
# 1 key
# 2 text
{
# 3 index
. #+1 Duplicate the index
# Find the index of the key letter
l% #+1 Indice modulo key
3$ #+2 Duplicate the key
= #+1 Get the key letter
4$? #+1 Search the letters index
# Find the index of the text letter
\ #+1 Get the index
2$ #+2 Get the text
= #+1 Get the text letter
4$? #+0 Search the letters index
# 3 key index
# 4 letter index
\- #+1 get the index of the new letter
62% #+1 wrap the index around the dictionary
3$ #+2 Get the dictionary
\> #+1 remove the first part of the dict around the target letter
1< #+1 remove everythin after
}%
\;
\;
\;
```
[Answer]
## VBA, 288
Doesn't quite beat the listed VB.NET score (but I'm getting close):
```
Sub h(k,s)
v=Chr(0)
Z=Split(StrConv("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",64),v)
a=Split(StrConv(s,64),v):b=Split(StrConv(k,64),v)
For l=0 To Len(s)-1
j=l Mod Len(k)
g=0
For i=0 To 62:g=g+i*((Z(i)=b(j))-(Z(i)=a(l))):Next
x=x &Z(IIf(g<0,g+62,g))
Next
s=x
End Sub
```
**Usage:**
```
Sub test()
k = "ThisIsAKey"
s = "CoqKuGRUw29BiDTQmOpJFpBzlMMLiPb8alGruFbu"
h k, s
MsgBox s
End Sub
```
Thanks to [Joey](https://codegolf.stackexchange.com/users/15/joey) for the tip!
[Answer]
**C,186**
A bit late but .. (lines broken to avoid horizontal scrollbar).
```
char a[99],*s,*t;k,j;main(int m,char**v)
{for(;j<26;++j)a[j]=32|(a[j+26]=65+j),
a[52+j]=48+j;while(*v[2])
putchar(a[s=strchr(a,v[1][k++%strlen(v[1])])
,t=strchr(a,*v[2]++),s>t?t-s+62:t-s]);}
```
Nonbroken lines
```
char a[99],*s,*t;k,j;main(int m,char**v){for(;j<26;++j)a[j]=32|(a[j+26]=65+j),a[52+j]=48+j;while(*v[2])putchar(a[s=strchr(a,v[1][k++%strlen(v[1])]),t=strchr(a,*v[2]++),s>t?t-s+62:t-s]);}
```
A discussion about the process of golfing this code can be found here:
<http://prob-slv.blogspot.com/2013/04/code-golf.html>
[Answer]
## JavaScript 248
```
var v= 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
function d(k,c){var a,b,o,x
a=k.charAt(0)
x=v.indexOf(a)
b=v.substr(x)+v.substring(0,x)
o= v.charAt(b.indexOf(c.charAt(0)))
k=k.substr(1)+a
c=c.substr(1)
return (c)?o+d(k,c):o}
```
[Answer]
# Uiua, 42 characters
```
A←⊂/⊂⊞+"aA"⇡26+@0⇡10
&p‚äè-‚à©(‚äó‚à∂A)‚ÜØ‚ñ≥,‚à∂&sc&scA
```
-4 thanks to Unrelated String
[Answer]
## Haskell (169)
```
import List
main=do c<-y;t<-y;putStrLn$map((k!!).(`mod`62))$zipWith(-)(g t)(cycle$g c)
k=['a'..'z']++['A'..'Z']++['0'..'9']
y=getLine
f(Just x)=x
g=map$f.(`elemIndex`k)
```
[Answer]
# J: 91 characters
```
[:{&{.&t({&t"0&(({.t=.1|.^:(i.62)a.{~(97+i.26),(65+i.26),48+i.10)&i.)"0@:$~#)|:@(i."1.,"0)]
```
For example:
```
g=:[:{&{.&t({&t"0&(({.t=.1|.^:(i.62)a.{~(97+i.26),(65+i.26),48+i.10)&i.)"0@:$~#)|:@(i."1.,"0)]
'ThisIsAKey' g 'CoqKuGRUw29BiDTQmOpJFpBzlMMLiPb8alGruFbu'
ThisWorksEquallyWellWithNumbers123894576
```
[Answer]
# [Scala](http://www.scala-lang.org/), 156 bytes
Golfed version. [Try it online!](https://tio.run/##RU/LasMwELz7K5ZA0Aq7ovTWBhdy6MkuodSn3lRnU@TIsoiUktj4212pSulp57EMM66VWi7DZ0eth1epDNDFk9k72FoLU5bBt9TgnxDf/UmZryIdXj7fAJQLVkUThCl@1iUyyfzARsbzHNk24o@E7yN@ZHzTiFHZGEiyF@1gvDJnqfUVKy4OWvpQgIte2qmVjlAVXUivEWuhzJ4uuwMqfvdPOp7XwqmR@Pp2Z9EfU715gd8BFZSwqui6yhJvIu/V2wO97P60E7mz9sHwYRA0PMg2ZHhtMFk8m5cf)
```
(K,T)=>{val L=('a'to'z')++('A'to'Z')++('0'to'9');T.zip(Stream.continually(K).flatten).map{case(i,j)=>L((L.indexOf(i)-L.indexOf(j)+L.size)%L.size)}.mkString}
```
Ungolfed version. [Try it online!](https://tio.run/##TVDLTsJAFN33K05IzMwEbIw7TTBh4aoYYuzK3dje1sHptGkHAxi@vd4yLbC753VfXaat7vv6a0uZx5s2DrT35PIOq6bBXwTkVMC32nVF3VYyecaHb40rF0inUk0FlucE8KstLHlPbcecFFrA1xBHoTCfM14F/CnUxZ6b0vjBLR6C@CQu2prpqR3ng/WsyjQ@mkbyeNJVnNXOG7fT1h5kouLCas44FYYAcaX5JGS6I0izwFZh@TJqwFrKdWxcTvtNIY3CPa6QnXOGllzpvxXurvUYP11G/IRXRAMXhfUTXn@W0GE24nTAlXl/pNfNxLXU7axn4ebV/OKhf8P9vHUyWFR06vt/)
```
object Main extends App {
def transform(K: String, T: String): String = {
val letters = ('a' to 'z') ++ ('A' to 'Z')
val digits = '0' to '9'
val L = letters ++ digits
(T.zip(Stream.continually(K).flatten))
.map { case (i, j) =>
L((L.indexOf(i) - L.indexOf(j) + L.length) % L.length)
}
.mkString
}
val K = "Key"
val T = "miQ2eEO"
val result = transform(K, T)
println(result)
}
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `s`, 136 [bitsv2](https://github.com/Vyxal/Vyncode/blob/main/README.md), 17 bytes
```
LẎZƛ÷kr₀Ǔ:£~ḟǓ∇_ḟ¥i
```
[Try it Online!](https://vyxal.pythonanywhere.com/?v=2&c=1#WyI9cyIsIiIsIkzhuo5axpvDt2ty4oKAx5M6wqN+4bifx5PiiIdf4bifwqVpIiwiIiwibWlRMmVFT1xuS2V5Il0=)
Bitstring:
```
0110000111010001100100100100100010010101101010000010110100010111011110111110110000101100000011001010100000111000011100111110110100111001
```
Takes message then key
## Explained
```
LẎZƛ÷kr₀Ǔ:£~ḟǓ∇_ḟ¥i­⁡​‎‎⁡⁠⁡‏⁠‎⁡⁠⁢‏‏​⁡⁠⁡‌⁢​‎‎⁡⁠⁣‏‏​⁡⁠⁡‌⁣​‎‎⁡⁠⁤‏‏​⁡⁠⁡‌⁤​‎⁠‎⁡⁠⁢⁢‏⁠‎⁡⁠⁢⁣‏⁠‎⁡⁠⁢⁤‏⁠‎⁡⁠⁣⁡‏‏​⁡⁠⁡‌⁢⁡​‎‎⁡⁠⁣⁢‏⁠‎⁡⁠⁣⁣‏‏​⁡⁠⁡‌⁢⁢​‎‎⁡⁠⁢⁡‏⁠‎⁡⁠⁣⁤‏⁠‎⁡⁠⁤⁡‏‏​⁡⁠⁡‌⁢⁣​‎‎⁡⁠⁤⁢‏‏​⁡⁠⁡‌⁢⁤​‎‎⁡⁠⁢⁡‏⁠‎⁡⁠⁤⁣‏⁠‎⁡⁠⁤⁤‏‏​⁡⁠⁡‌⁣⁡​‎‎⁡⁠⁢⁡⁡‏‏​⁡⁠⁡‌⁣⁢​‎‎⁡⁠⁢⁡⁢‏⁠‎⁡⁠⁢⁡⁣‏‏​⁡⁠⁡‌­
LẎ # ‎⁡Repeat the key to the length of the message
Z # ‚Äé‚Å¢Zip each character in the message to the extended key
∆õ # ‚Äé‚Å£To each pair:
kr₀Ǔ # ‎⁤ Push the string a-zA-Z0-9
:£ # ‎⁢⁡ and store a copy in the register
÷ ~ḟ # ‎⁢⁢ Find the position of the key character, not popping the alphabet string
Ǔ # ‎⁢⁣ Rotate the alphabet string left that many times
÷ ∇_ # ‎⁢⁤ Put the message character at the top of the stack, followed by the rotated alphabet
ḟ # ‎⁣⁡ Find the index of the message character in that alphabet
¥i # ‎⁣⁢ And index into the original alphabet string
üíé
```
Created with the help of [Luminespire](https://vyxal.github.io/Luminespire).
] |
[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/45139/edit).
Closed 9 years ago.
[Improve this question](/posts/45139/edit)
## Number fight game
* **Setup**
Each ai is given a random number from 1 to 100. The starting number is the average of these two numbers.
* **Gameplay**
Each ai knowing its own target, the opposite target and the current number, chooses which function to apply to the current number.
* **WIN conditions**
The first ai that reaches its number wins.
* **Scoring details**
The score is given in a tournament: each ai will fight all the other ais and it will get a score equal to the average of the points scored against the opponents.
---
The controller script is limited to Python-only functions, but if you can provide a controller that allows other languages your are welcome.
Controller script for reference:
```
import random
def increment(a): return a + 1
def decrement(a): return a - 1
def double(a) : return 2 * a
def halve(a) : return a // 2
def square(a) : return a**2
def sqrt(a) : return int(a**0.5)
def nop(a) : return a
ALLOWED_FUNCTIONS = [increment, decrement, double, halve,
square, sqrt, nop]
def number_obtainer_master(ai_1,ai_2,logging):
"""
Handles a number-fight game between two bots.
SETUP: Each one of the 2 ais gets a random number from 1 to 100
as its target. The starting number is the average of the two numbers.
GAMEPLAY: Each ai should try to reach its goal before the opponent,
the first ai that reaches its number wins.
Note: After 500 turns, if noone has won, the game is declared drawn.
"""
target_numbers = [random.randint(1,100), random.randint(1,100)]
starting_number = sum(target_numbers) // 2
number = starting_number
if logging:
print("""The match is about to start, the contending AIs are:
{} - whose target is {}
{} - whose target is {}
The starting number is: {}\n\n""".format(ai_1.__name__,target_numbers[0],
ai_2.__name__,target_numbers[1],
starting_number))
for turn in range(500):
if logging:
print("""\n --- Turn: {} --- """.format(turn))
ais = [ai_1,ai_2]
for ai in ais:
if ai == ai_1:
ai_function = ai(target_numbers[0],target_numbers[1],number)
else:
ai_function = ai(target_numbers[1],target_numbers[0],number)
if ai_function not in ALLOWED_FUNCTIONS:
raise ValueError("Invalid function was returned")
number = ai_function(number)
if logging:
print("{} chose {}: the number now is: {}".format(
ai.__name__,ai_function.__name__,number))
if number in target_numbers:
if logging:
print("{} won.\n\n".format(ai.__name__))
return 1 if number == target_numbers[0] else 0
if logging:
print("After 500 turns the match is not ended yet: tie.\n\n")
return 0.5
def compare_strength(ai_1,ai_2,accuracy):
"""
Returns how many times ai_1 is better than ai_2.
Harder than it should be to compensate advantage of going first.
"""
ai_1_score = sum([number_obtainer_master(ai_1,ai_2,False) for _ in range(accuracy//2)])
ai_1_score = sum([ 1 - number_obtainer_master(ai_2,ai_1,False) for _ in range(accuracy//2)])
return ai_1_score / accuracy # 1 means perfect
def tournament(ais,accuracy):
"""
Lets each ai fight all the other ais and returns a nicely sorted leaderboard.
"""
scores = []
for ai in ais:
score = sum ( (compare_strength(ai,opponent,accuracy) for opponent in ais if opponent != ai) ) / len(ais)
scores.append((ai.__name__,score))
return sorted(scores, key=lambda x: x[1], reverse= True)
## Default simple ais
def sleeping_ai(self_target,opposite_target,current_number):
return nop
def simplistic_ai(self_target,opposite_target,current_number):
return increment if current_number < self_target else decrement
def cleverish_ai(self_target,opposite_target,current_number):
target,n = self_target,current_number
if n*2 < target:
return double
elif n//2 == target:
return halve
elif n**2 == target:
return square
return increment if current_number < self_target else decrement
def increment_ai(self_target,opposite_target,current_number):
return increment
## Partecipants ais
print(tournament([sleeping_ai,simplistic_ai,
cleverish_ai,increment_ai],200))
```
]
|
[Question]
[
Your challenge today is to implement a [t9](http://en.wikipedia.org/wiki/T9_(predictive_text))-like functionality.
You will implement a function that will only have 2 parameters.
You will receive 1 phone number in a string and the content of a text file with a list of words (don't assume a specific newline style).
You can use the link <https://raw.githubusercontent.com/eneko/data-repository/master/data/words.txt> to test the functionality, or use `/usr/share/dict/words` (check [A text file with a list of words [closed]](https://stackoverflow.com/questions/741003/a-text-file-with-a-list-of-words) for more information).
You can assume that you will always receive at least 2 numbers.
Given the number, you will read from a list of words and returns the words starting with the letters mapping to those words. This means that the input should be only numbers from 2 to 9.
You can do whatever you want if you receive invalid input.
If no match is found, you can return an empty list, `null`/`nil` or `0`.
Remember that the cellphone keys are mapped to their equivalent chars:
* 0 and 1 are invalid
* 2 matches [abc]
* 3 matched [def]
* 4 matches [ghi]
* 5 matches [jkl]
* 6 matches [mno]
* 7 matches [pqrs]
* 8 matches [tuv]
* and 9 matches [wxyz]
Examples:
```
f('52726')
//returns ["Japan","japan","Japanee","Japanese","Japanesque"...,"larbowlines"]
f('552')
//returns ["Kjeldahl","kjeldahlization","kjeldahlize"...,"Lleu","Llew"]
f('1234')
//makes demons fly out your nose or divide by 0
f('9999')
//returns ["Zyzzogeton"]
f('999999')
//returns [] or null/nil or 0
```
After you run your function, you can print it in any way you wish.
Rules:
* Standard loopholes are INVALID
* You must return something, even if it is `null`/`nil`
Javascript will return `undefined` if you don't return something, therefore this rule.
* You cannot use or re-implement other's answers or copy my implementation.
* You can assume, for Javascript, that the browser will be already opened and that the `innerText`/`textContent` of the automatic element will be passed as the 2nd parameter
* For compiled languages, you cannot pass special arguments to the compiler
* You can receive the file name over compiler arguments
* Variables, macros, global variables, constants, non-standard classes and all the sort passing other values inside the function will be considered invalid.
* In Javascript, variables without the keyword `var` render your code invalid
* Your function will be named `f`
* You can only and only have 2 arguments on your function
* Try to keep your code under 500 seconds to run.
* You don't have to worry about whitespace
* You must use only [ASCII](http://en.wikipedia.org/wiki/ASCII) printable characters.
Exceptions are languages that **only** use non-printable characters (APL and whitespace are 2 examples).
Scoring:
* **Lowest number of bytes win**
* Having invalid [ASCII](http://en.wikipedia.org/wiki/ASCII) printable characters in your answer, will count as the answer being encoded in [UTF-32](http://en.wikipedia.org/wiki/UTF-32)
The exception to the encoding will make your answer be count by **characters**.
* Only the function body counts, don't count anything else you do outside it
* Bonus of -30% if you make a prediction system based on the neighborhood or most common words
* Bonus of -20% in size if you only return the first 5 matches for each letter corresponding to the first number (e.g.: 245 would returns 5 words starting with 'a', 5 starting with 'b' and 5 starting with 'c').
Here is an example of an implementation, using Javascript:
```
function f(phone, words)
{
var keypad=['','','abc','def','ghi','jkl','mno','pqrs','tuv','wxyz'];
var regex='';
for(var i=0,l=phone.length;i<l;i++)
{
regex+='['+keypad[phone[i]]+']';
}
var regexp=new RegExp('\\s('+regex+'[a-z]*)\\s','gi');
return words.match(regexp);
}
```
To run it, open the list link and run, for example:
```
f('9999',document.getElementsByTagName('pre')[0].innerText);
//returns [" Zyzzogeton "]
```
This example was tested and works under Opera 12.17 64bits on Windows 7 Home Edition 64bits.
[Answer]
# CJam, 28 bytes
```
q~{el{'h-_9/-D+3/}%s1$#!},p;
```
Takes input in the form of `"<number>" [<list of words>]`
Example:
```
"52726" ["Japan" "japan" "Japanee" "Japanese" "Japanesque" "larbowlines" "ablution" "ablutionary" "abluvion" "ably" "abmho" "Abnaki" "abnegate"]
```
Output:
```
["Japan" "japan" "Japanee" "Japanese" "Japanesque" "larbowlines"]
```
Not going for any bonus for now.
[Try the code online here](http://cjam.aditsu.net/) but for actual time measurements, run it on the [Java compiler](http://sourceforge.net/projects/cjam/)
*Note that CJam represents empty lists like `""`*
To convert the raw wordlist into CJam list use the following code with the wordlist as input:
```
qN/p
```
[Answer]
# Java: 395
This forms a regex pattern based on the letters that are allowed for each number, and then tacks on a .\* at the end to match any following characters.
Here is the golfed version:
```
static ArrayList<String> f(String n,ArrayList<String> d){String[] k={"","","([A-Ca-c])","([D-Fd-f])","([G-Ig-i])","([J-Lj-l])","([M-Om-o])","([P-Sp-s])","([T-Vt-v])","([W-Zw-z])"};String r="";for(int i=0;i<n.length();++i)r+=k[n.charAt(i)-'0'];r += ".*";Pattern p=Pattern.compile(r);ArrayList<String> a=new ArrayList<String>();for(String w:dictionary)if(p.matcher(w).matches())a.add(w);return a;}
```
And here is the ungolfed version for read-ability
```
public static ArrayList<String> f(String phoneNumber, ArrayList<String> dictionary) {
String[] KEY_VALUES = {"", "", "([A-Ca-c])", "([D-Fd-f])", "([G-Ig-i])",
"([J-Lj-l])", "([M-Om-o])", "([P-Sp-s])",
"([T-Vt-v])", "([W-Zw-z])"};
String regex = "";
for (int i = 0; i < phoneNumber.length(); ++i) {
regex += KEY_VALUES[phoneNumber.charAt(i) - '0'];
}
regex += ".*";
Pattern p = Pattern.compile(regex);
ArrayList<String> answers = new ArrayList<String>();
for (String word : dictionary) {
if (p.matcher(word).matches()) {
answers.add(word);
}
}
return answers;
}
```
[Answer]
# C# .NET 4.5 235
This should work:
```
IEnumerable<string>F(string n,string d){IEnumerable<string>w=d.Split(null).ToList();string[]a={"","","abc","def","ghi", "jkl","mno","pqrs","tuv","wxyz"};foreach(var i in n){w=w.Where(x=>x.IndexOfAny(a[i-'0'].ToArray())>0);}return w;}
```
[Answer]
# Python 2 (155 bytes)
Should also work in Python 3 with the appropriate replacements (`string`->`bytes`, `b` prefix on strings, etc.).
I wasn't sure if having the `maketrans` call outside the function is considered "fair"; if not, the function is 134 bytes with it moved inside.
**EDIT:** Dropped one byte from a stupid oversight.
With prepared `maketrans`, 67 bytes:
```
from string import maketrans
t=maketrans('abcdefghijklmnopqrstuvwxyz','22233344455566677778889999')
def f(n,w):
return[x for x in w.split()if x.lower().translate(t).startswith(n)]
```
With `maketrans` in body, 134 bytes:
```
from string import maketrans
def f(n,w):
return[x for x in w.split()if x.lower().translate(maketrans('abcdefghijklmnopqrstuvwxyz','22233344455566677778889999')).startswith(n)]
```
With `import` and `maketrans` in body, 155 bytes:
```
def f(n,w):
return[x for x in w.split()if x.lower().translate(__import__('string').maketrans('abcdefghijklmnopqrstuvwxyz','22233344455566677778889999')).startswith(n)]
```
Test call:
```
print f('9999',open('words.txt','rt').read())
```
[Answer]
# PHP 5.4+ (~~171~~ 186-20% = 148.8 bytes):
Well, this is quite a huge answer, but well.
I hope this brings more people to answer.
This function expects the **raw** content being read.
Here is the code:
```
function f($_,$a){$s=[2=>abc,def,ghi,jkl,mno,pqrs,tuv,wxyz];$a=preg_split('@\r\n|\r|\n@',$a);for($i=0;$c=$_[$i];++$i)foreach($a as$k=>$v)if(!strpos(1..$s[$c],$v[$i])||$t[$v[0]]++>4)unset($a[$k]);return$a;}
```
This works by verifying that the letter is in the list of allowed letters.
Example: the input `36` would make to check if `1abc` has the first letter of the word and that `1def` has the 2nd letter.
I append `1` so it doesn't check if the letter is in the 1st position (which would return `0` and that would evaluate to `false`). `if(!strpos(1..$s[$c],$v[$i]))` or `if(!strpos($c.$s[$c],$v[$i]))` will have the same effect, but the 1st confuses more and I like it.
Failing to do so, will remove the word.
With no words left, it returns an empty array.
To test this online, go to <http://writecodeonline.com/php/> and create a simple variable with a word for line.
A testable example:
```
function f($_,$a)
{
$s=array(2=>abc,def,ghi,jkl,mno,pqrs,tuv,wxyz);
$a=preg_split('@\r\n|\r|\n@',$a);
for($i=0;$c=$_[$i];++$i)
foreach($a as$k=>$v)
if(!strpos(1..$s[$c],$v[$i]) || $t[$v[0]]++>4)
unset($a[$k]);
return$a;
}
$lines=<<<WORDS
one
two
three
four
five
six
seven
eight
nine
ten
WORDS;
var_dump(f('36',$lines));
```
This should output:
```
array(1) {
[3]=>
string(4) "four"
}
```
To work on older php versions, replace `$s=[2=>abc,def,ghi,jkl,mno,pqrs,tuv,wxyz];` by `$s=array(2=>abc,def,ghi,jkl,mno,pqrs,tuv,wxyz);`
---
For the 20% bonus:
To reduce the code I simply added `||$t[$v[0]]++>4`, which checks how many times the first letter was used.
In php, `$t` doesn't need to be defined, helping to reduce a big chunk of *37.2* bytes.
To see this effect, use the following variable as the 2nd argument:
```
$lines=<<<WORDS
one
two
three
four
five
six
seven
eight
nine
ten
twelve
time
tutor
test
truth
WORDS;
```
] |
[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 9 years ago.
[Improve this question](/posts/42763/edit)
There's the old, well hashed version of the question that uses Dynamic Programming to calculate the minimum number of coins to reach a target value, but what if the coins you're given can't reach the target (such as {4, 8, 12} trying to total 33)? What if you're satisfied with "close enough" totals?
It seems to me that there's two considerations with this:
1) Getting as close to the target value as possible, and
2) Using as few coins as possible.
For example, given a target value of X, if you an reach X-1 with 5 coins, but X-2 with only 2 coins, (where X is sufficiently large that 1 and 2 are almost equal in relative value [such as 500, as opposed to 5]), then it seems that X-2 with 2 coins could be the "better" answer, even though it's not the closest total to the target value.
How would one go about setting up this problem? It's too ambiguous for me to wrap my head around.
]
|
[Question]
[
**This question already has answers here**:
[Render "Digital Clock Style" Numbers](/questions/997/render-digital-clock-style-numbers)
(40 answers)
Closed 9 years ago.
The challenge is make a digital clock that exhibits ascii numbers in a 24-hour format like:
```
_ _ _ _
|_| |_| . |_| |_|
|_| |_| . |_| |_|
```
or
```
_ _ _
_| _| . |_| |_
|_ _| . | _|
```
and updates the screen every 1 minute (or every 1 second, for praticity reasons). It must reset to 00:00 after 23:59.
[Answer]
# **Python, 411 408 chars**
```
import time,os
s=" ";p=".";a=s*3;b=" _ ";c="|_|";d="| |";e="| ";f=" |";g="|_ ";h=" _|";P=[s,p,p]
z=[[b,d,c],[a,f,f],[b,h,g],[b,h,h],[a,c,f],[b,g,h],[b,g,c],[b,f,f],[b,c,c],[b,c,h]]
A=range(10);B=A[:6];C=A[:3]
while 1:
for i in C:
for j in A:
if i==2&(j==4):break
for k in B:
for l in A:
for m in C:
print z[i][m]+s+z[j][m]+P[m]+z[k][m]+z[l][m]
time.sleep(1);os.system('clear')
```
Not so pretty but working.
] |
[Question]
[
**This question already has answers here**:
[Look and say sequence [duplicate]](/questions/2323/look-and-say-sequence)
(25 answers)
Closed 9 years ago.
There is a sequence of numbers called the "Look-and-Say Numbers".
Here is an example of the first 5 terms of the sequence, starting at 1 (with spaces added between the digits):
```
1
1 1
2 1
1 2 1 1
1 1 1 2 2 1
```
The pattern is simple, once you see it.
The sequence starts with 1. There is one 1, so the next number is 11 (as in one of the number 1).
In this number, there are 2 1s, so the next number is 21.
In this number there is 1 2, and 1 1, so the next number is 1211.
In this number there is 1 1, followed by 1 2, followed 2 1s - so the number is 111221.
## The Task
You must write a program that generates the first n terms of this sequence, where n is given by stdin. The sequence will start at 1.
This is a code-golf task, so shortest code wins.
[Answer]
## Mathematica, 68 bytes
There's no STDIN in Mathematica, so here is a function instead
```
s=FromDigits/@NestList[Flatten[Reverse@@@Tally/@Split[#]]&,{1},#-1]&
```
Usage:
```
s[5]
> {1, 11, 21, 1211, 111221}
```
] |
[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/6380/edit).
Closed 5 years ago.
[Improve this question](/posts/6380/edit)
Given a list of strings and a length, give all combinations of that list with the given length. The problem is: **your code must not be recursive.** Yes, it can be done. I have done it myself, when I had no clue what this "recursion" was.
**Input:** A list of strings of an undefined length, and an integer defining the length of the combination. The strings will be at least one character long, and will only contain letters or numbers. The way of input will be specified by you, the programmer.
**Output:** A list of possible combinations as strings, not necessarily distinct (although you can make it that way, if you like). You do not have to sort the list.
**Test Cases:**
As said before, the method of input will be specified by you.
`[a,b] 3 -> Nothing`
`[1,0,0] 2 -> 10 10 00`, or `00 10` if distinct.
`[abc,bcd,cde] 2 -> abcbcd abccde bcdcde`
If you even manage to do this, I will commend you. As always, shortest code wins. Good luck.
[Answer]
## GolfScript (44 42 32 chars)
```
n%){\,=}+[[]]@1/{`{1$+}+%}%;\,n*
```
This takes input on stdin as a list of newline-separated strings followed by a line containing the desired subset size. It assumes that none of the input strings is empty. It takes some inspiration from Howard's solution, and can be shortened by two chars if using his input format:
```
~{\,=}+[[]]@1/{`{1$+}+%}%;\,n*
```
Output is a newline separated list of concatenations.
E.g.
```
$ golfscript.rb subcombo.gs <<END
> a
> b
> c
> 2
> END
ab
ac
bc
```
Note: this uses a horribly inefficient algorithm. A much nicer implementation in terms of performance is (62 61 chars)
```
n%)~\:S;2\?({2S,?<}{:s.~)&.s+.s^@4*/|}/{:x;S{;x.2/:x;1&},}%n*
```
which uses [Gosper's hack](https://softwareengineering.stackexchange.com/questions/67065/whats-your-favorite-bit-wise-technique/67087#67087).
[Answer]
### GolfScript, 33 35 34 characters
```
~[[]]@{\{.[2$]+.,4$={puts}*}%\}%];
```
Assumes that the input is list of strings and number in GolfScript compatible format (on STDIN). Example:
```
> ["abc" "bcd" "cde"] 2
abcbcd
bcdcde
abccde
```
You can also test this version [online](http://golfscript.apphb.com/?c=OydbImFiIiAiY2QiICJlZiIgImdoIiAiaWoiXSAzJwoKfltbXV1Ae1x7LlsyJF0rLiw0JD17LnB1dHN9Kn0lXH0lXTs=).
*Edit:* The first version was broken.
[Answer]
## Mathematica, 21
```
""<>##&@@@Subsets@##&
```
Usage:
```
""<>##&@@@Subsets@##&[{"a", "b", "c", "d"}, {3}]
```
>
> {"abc", "abd", "acd", "bcd"}
>
>
>
[Answer]
## Mathematica, 34 30 24 characters
```
StringJoin@@@Subsets@@#&
```
where i is input consisting of a list of the strings and the length of combinations.
For example,
```
k = {{"abc", "bcd", "cde"},{2}};
StringJoin@@@Subsets@@#&[k]
(* out *)
{"abcbcd", "abccde", "bcdcde"}
```
---
Additional examples:
```
d = {"a", "b", "cd", "e", "fgh"}
m = {d, {2}}
n = {d, {3}}
p = {d, {4}}
StringJoin@@@Subsets@@#&[m]
StringJoin@@@Subsets@@#&[n]
StringJoin@@@Subsets@@#&[p]
(* out *)
{"ab", "acd", "ae", "afgh", "bcd", "be", "bfgh", "cde", "cdfgh", "efgh"}
{"abcd", "abe", "abfgh", "acde", "acdfgh", "aefgh", "bcde", "bcdfgh", "befgh", "cdefgh"}
{"abcde", "abcdfgh", "abefgh", "acdefgh", "bcdefgh"}
```
[Answer]
## J, 50 48 46 44 43 41 35 characters
```
;"1(>@{:{."1(i.@!@#A.])@}:)".1!:1[1
```
Takes input from the keyboard. I've changed the input format from previous answers. Strings should come first, single-quoted, and separated by semi-colons, followed by the integer.
```
;"1(>@{:{."1(i.@!@#A.])@}:)".1!:1[1
'hello';'mr';'wibble';2
hellomr
hellowibble
mrhello
mrwibble
wibblehello
wibblemr
```
Entering a number larger than the largest possible combination just gives the largest possible combination:
```
;"1(>@{:{."1(i.@!@#A.])@}:)".1!:1[1
hello mr wibble 8
hellomrwibble
hellowibblemr
mrhellowibble
mrwibblehello
wibblehellomr
wibblemrhello
```
[Answer]
### Scala 52
Not a challenge - know your API:
```
def c(l:Seq[_],n:Int)=l combinations n mkString "\n"
```
invocation sample:
```
scala> c(Seq("foo", "bar", "foobar"), 2)
res199: String =
List(foo, bar)
List(foo, foobar)
List(bar, foobar)
```
Now beary605 observes that he didn't thought about library methods *combinations*, so I come up with this one, which doesn't use *combinations*, but maybe he now will come up with a permutation prohibition.
### Scala 63 (without literal combinations method):
```
def c(l:Seq[_],n:Int)=l.permutations.map(_.take(2).toSet).toSet
```
[Answer]
# Java, 208 characters
**No imports, two method calls**,
so it should be pretty guaranteed that there are no *implisit* recursive calls neither.
```
class S{public static void main(String[]a){int n=a.length-1,k=Integer.parseInt(a[0]),i=0,j;while(++i<1<<n)if(Integer.bitCount(i)==k){String s="";for(j=0;j<n;)if((i&1<<j++)!=0)s+=a[j];System.out.println(s);}}}
```
Slightly more readable:
```
class S{
public static void main(String[]a){
int n=a.length-1,k=Integer.parseInt(a[0]),i=0,j;
while(++i<1<<n)
if(Integer.bitCount(i)==k){
String s="";
for(j=0;j<n;)
if((i&1<<j++)!=0)
s+=a[j];
System.out.println(s);
}
}
}
```
Takes input from command line arguments. First arg is the length and the rest is the strings. Outputs each combination on a separate line:
```
$ java S 3 A B C D
ABC
ABD
ACD
BCD
```
] |
[Question]
[
# preface
In a very heated situation you have to go even further with golfing.
(e.g. in a challenge where your answer is 100 characters long and it is just embarrassing that you couldn't make it 99)
In that case, from now on you use the winner's algorithm of this challenge :)
# goal
You have to write a program that takes an uint32 and returns the most compressed form.
```
$ mathpack 147456
9<<14
```
* There will be multiple solutions for a number. Pick the shortest one
* If the compressed form is longer or equal to the original number, return the original number
# rules
* write in any language - output in any language
* i'm aware of that in C `'abc'` is `6382179` and you can achieve pretty good results with this conversion. but languages are separated in this challenge so don't lose heart
* it is prohibited to use external variables. only operators and literals and math related functions!
# scoring
here are the test cases: [pastebin.com/0bYPzUhX](http://pastebin.com/0bYPzUhX)
your score (percent) will be the ratio of
`byte_size_of_your_output / byte_size_of_the_list` **without line breaks**.
(you have to do this by yourself as i'll just verify the best codes just in case)
winners will be chosen by score and **language of output**!
**examples:**
```
$ mathpack 147456 | mathpack 97787584 | mathpack 387420489
9<<14 | 9e7^9e6 | pow(9,9)
```
[Answer]
# Code: Mathematica, Output: Julia, ~98.9457% (20177/20392 bytes)
```
optimise[n_] :=
Module[{bits, trimmedBits, shift, unshifted, nString, versions,
inverted, factorised, digits, trimmedDigits, exponent, base,
xored, ored, anded},
nString = ToString@n;
versions = {nString};
(* Try bitshifting *)
bits = IntegerDigits[n, 2];
trimmedBits = bits /. {x___, 1, 0 ..} :> {x, 1};
shift = ToString[Length[bits] - Length[trimmedBits]];
unshifted = ToString@FromDigits[trimmedBits, 2];
AppendTo[versions, unshifted <> "<<" <> shift];
(* Try inverting *)
inverted = ToString@FromDigits[1 - PadLeft[bits, 32], 2];
AppendTo[versions, "~" <> inverted];
(* Try invert/shift/invert *)
trimmedBits = bits /. {x___, 0, 1 ..} :> {x, 1};
shift = ToString[Length[bits] - Length[trimmedBits]];
unshifted = ToString@FromDigits[trimmedBits, 2];
AppendTo[versions, "~(~" <> unshifted <> "<<" <> shift <> ")"];
(* Try factoring *)
factorised = Riffle[
FactorInteger[n]
/. {a_, 1} :> ToString@a
/. {a_Integer, b_Integer} :> ToString[a] <> "^" <> ToString[b]
, "+"] <> "";
AppendTo[versions, factorised];
(* Try scientific notation *)
digits = IntegerDigits[n, 10];
trimmedDigits = digits /. {x___, d_ /; d > 0, 0 ..} :> {x, d};
exponent = ToString[Length[digits] - Length[trimmedDigits]];
base = ToString@FromDigits[trimmedDigits, 10];
AppendTo[versions, base <> "e" <> exponent];
(* Don't try hexadecimal notation. It's never shorter for 32-bit uints. *)
(* Don't try base-36 or base-62, because parsing those requires 12 characters for
parseint("...") *)
SortBy[versions, StringLength][[1]]
];
mathpack[n_] :=
Module[{versions, increments},
increments = Range@9;
versions = Join[
optimise[#2] <> "+" <> ToString@# & @@@ ({#, n - #} &) /@
Reverse@increments,
{optimise@n},
optimise[#2] <> "-" <> ToString@# & @@@ ({#, n + #} &) /@
increments,
optimise[#2] <> "*" <> ToString@# & @@@
Cases[({#, n / #} &) /@ increments, {_, _Integer}],
optimise[#2] <> "/" <> ToString@# & @@@ ({#, n * #} &) /@
increments
];
SortBy[versions, StringLength][[1]]
];
```
The function takes a *number* and returns the shortest *string* it finds. Currently it applies four simple optimisations (I might add more tomorrow).
You can apply it to the entire file (to measure its score) as follows:
```
input = StringSplit[Import["path/to/benchmark.txt"]];
numbers = ToExpression /@ input;
output = mathpack /@ numbers;
N[StringLength[output <> ""]/StringLength[input <> ""]]
```
Note that some of these optimisations assume that you're on a 64-bit Julia, such that integer literals give you an `int64` by default. Otherwise, you'll be overflowing anyway for integers greater than 231. Using that assumption we can apply a few optimisations whose intermediate steps are actually even larger than 232.
**EDIT:** I added the optimisation suggested in the OP's examples to bitwise *xor* two large numbers in scientific notation (actually, for all of *xor*, *or* and *and*). Note that extending the `xormap`, `ormap` and `andmap` to include operands beyond 232 might help finding additional optimisations, but it doesn't work for the given test cases and only increases run time by something like a factor of 10.
**EDIT:** I shaved off another 16 bytes, by checking all `n-9, n-8, ..., n+8, n+9` for whether any of *those* can be shortened, in which case I represented the number based on that, adding or subtracting the difference. There are a few cases, where one of those 18 numbers can be represented with 3 or more characters less than `n` itself, in which case I can make some extra savings. It takes about 30 seconds now to run it on all test cases, but of course, if someone actually "used" this function, he'd only run it on a single number, so it's still well under a second.
**EDIT:** Another incredible 4 bytes by doing the same for multiplication and division. 50 seconds now (the divided ones don't take as long, because I'm only checking these if the number is actually divisible by the factor of interest).
**EDIT:** Another optimisation that doesn't actually help with the given test set. This one could save a byte for things like 230 or 231. If we had uint64s instead, there'd be a lot of numbers where this could be a huge saving (basically, whenever the bit representation ends in a lot of 1s).
**EDIT:** Removed the *xor*, *or*, *and* optimisations altogether. I just noticed they don't even work in Julia, because (quite obviously) scientific notation gives you a float where bit-wise operators are not even defined. Interestingly, one or more of the newer optimisations seem to catch all of the cases that were shortened by these optimisations, because the score didn't change at all.
[Answer]
## Code: Mathematica, Output: C, ~62.1518% (12674/20392)
I thought I'd also give C a try because of those funny character literals. Currently this is the only thing this answer is trying, and it's working quite well.
```
mathpack[n_] := Module[{versions, charLiteral},
charLiteral = "'" <> StringReplace[Map[
Switch[#,
(*d_ /; d < 32,
"\\" <> IntegerString[#, 8],*)
10,
"\\n",
13,
"\\r"
39,
"\\'",
92 ,
"\\\\",
_,
FromCharacterCode@#] &,
FromDigits[#,
2] & /@ (Partition[PadLeft[IntegerDigits[n, 2], 32],
8] //. {{0 ..} .., x__} :> {x})
] <> "",
{(*"\\10" -> "\\b",
"\\11" -> "\\t",
"\\13" -> "\\v",
"\\14" -> "\\f",*)
RegularExpression["(?!<=\?)\?\?(?=[=/()!<>-]|$)"] -> "?\\?"
}
] <> "'";
versions = {ToString@n, charLiteral};
SortBy[versions, StringLength][[1]]
];
```
I hope I didn't miss anything, but this answer makes sure to escape backslashes, single quotation marks as well as trigraphs. There is some commented out code that uses octal or other escape sequences for non-printable characters, but I don't think that's actually necessary, because C should be able to deal with any bytes in character literals, afaik (please correct me if I'm wrong).
As with the other submission, test this with
```
input = StringSplit[Import["path/to/benchmark.txt"]];
numbers = ToExpression /@ input;
output = mathpack /@ numbers;
N[StringLength[output <> ""]/StringLength[input <> ""]]
```
[Answer]
# J to C (untested, but works in most cases, kind of a baseline answer.)
```
f=:(,~ (($&0) @: (8&-) @: (8&|) @: #)) @: #:
g=:($~ ((,&8) @: (%&8) @: #))@:f
toCString=:({&a.)@:#.@:g
toCString 6382179
abc
```
Outputs an string literal that, if entered in C, represents the number (as mentioned in the OP). This is not a serious submission, but rather something to strengthen my J skills, that I thought I'd share.
Alternative one-liner:
```
toCString=:({&a.) @: #. @: ($~ ((,&8) @: (%&8) @: #))@: (,~ (($&0) @: (8&-) @: (8&|) @: #)) @: #:
```
What J tries to make of this when you input it:
```
{&a.@:#.@:($~ ,&8@:(%&8)@:#)@:(,~ $&0@:(8&-)@:(8&|)@:#)@:#:
```
Thanks a bunch, J. Also, for those in 'the know' about J, visio rocks for creating more complex functions:
] |
[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/6454/edit).
Closed 2 years ago.
[Improve this question](/posts/6454/edit)
Given an a-by-b sized grid, and a chess knight, determine:
* A starting point and path the knight can take to visit every square in the grid
* or "NOT POSSIBLE", if not possible.
**Input:** Two integers, `a`, `b`.
**Output:** Numbers output in an a-by-b grid:
```
1 4 7 10
8 11 2 5
3 6 9 12
```
Where `1` is where the knight starts, `a*b` is where the knight ends, and the numbers signify the path the knight must take, in ascending order. The knight cannot land on the same square twice.
The rows of the grid must be separated with a newline, and the items in each row must be separated with a space.
**Test Cases:**
| is a newline.
`3 4 -> 1 4 7 10 | 8 11 2 5 | 3 6 9 12`
`2 3 -> NOT POSSIBLE`
If there is a solution there will be more than one: any valid solution is acceptable.
Shortest code wins. **Please do not use any programming languages that are known to produce short programs: e.x. GolfScript, APL, J, K, etc.**
[Answer]
### Ruby, 306 284 characters
```
w,h=eval"[#{gets}]"
f=Hash.new{|g,k|s,x,y,*r=k
x<0||y<0||x<w&&y<h&&s>0&&'$&(,268:'.bytes{|u|r|=f[[s-1,x-2+u%5,y-9+u/5]].select{|l|l[y*w+x]<1}}
g[k]=r.map{|l|l=l*1;l[y*w+x]=s;l}}
f[[1,0,0]]=[[1]+[0]*(w*h-1)]
(s=f[[w*h,w-1,h-1]][0]||(puts"NOT POSSIBLE"))&&s.each_slice(w){|f|puts f*" "}
```
Implementation in Ruby, takes input from STDIN and outputs to STDOUT. Although a little bit optimized it is still extremely slow on large grids.
```
> 5,3
NOT POSSIBLE
> 5,4
1 18 5 12 9
6 15 10 19 4
17 2 13 8 11
14 7 16 3 20
```
*Edit:* Ventero pointed out some improvements whiche saved several chars. I also changed the encoding of possible moves to be much shorter now.
[Answer]
## Python, 420
```
w,h=input()
s=w*h
d=range
def r(l):y=l/w;x=l%w;return[x+p+w*(q+y)for p,q in[(1,2),(2,1),(-2,1),(-1,2),(-1,-2),(-2,-1),(2,-1),(1,-2)]if 0<=x+p<w and 0<=q+y<h]
def f(p):
a={l:len(r(l))for l in r(p[-1])if l not in p}
for l in[k for k in a if a[k]==min(a.values())]:
x=f(p+[l])
if len(x)==s:return x
return p
e=f([0])
print len(e)<s and"NOT POSSIBLE"or'\n'.join([' '.join(`e.index(x+y*w)+1`for x in d(w))for y in d(h)])
```
I've sacrificed shorter code for reasonable performance, so it should be able to find solutions for boards up to 9x9 in under 3 seconds.
[Answer]
### Ruby ~~364~~ 359
```
K=->a,b{A,B=a,b;(0...A*B).each{|i|Z[[i]]};p"NOT POSSIBLE"}
Z=->v{c=v.last
abort (0...v.size).map{|i|{:i=>i+1,:x=>v[i]}}.sort_by{|i|i[:x]}.map{|i|i[:i]}.each_slice(B).map{|r|r*' '}*?\n if v.size==A*B
([[1,2],[2,1],[-2,1],[-1,2],[-1,-2],[-2,-1],[2,-1],[1,-2]].map{|d|o=(c/B)+d[0]
u=(c%B)+d[1]
(o>=0&&0<=u&&A>o&&B>u)?o*B+u :-1}.flatten-[-1]-v).each{|i|Z[v+[i]]}}
```
Same idea as my C# answer.
This gets invoked like this: `K[a,b]` and outputs the desired result to the console.
**Online demos:**
Test case 1: <http://ideone.com/yDiiS>
Test case 2: <http://ideone.com/WVUmX>
Example of a bigger board (4x5): <http://ideone.com/hItNo>
[Answer]
### C# ~~796~~ 793
```
using System;using System.Collections.Generic;using System.Linq;namespace Z{public class P{public static void Main(){new P().K(3,4);}int x, y;void K(int a, int b){x=a;y=b;for(var s=0;s<x*y;s++)K(new[]{s});Console.WriteLine("NOT POSSIBLE");}void K(int[] v){if(v.Length<x*y)foreach(var m in M(v))K(v.Concat(new[]{m}).ToArray());else{Console.WriteLine(String.Join("\n",v.Select((p,i)=>new{p,i}).OrderBy(e=>e.p).GroupBy(e=>e.p/y).Select(g=>String.Join(" ",g.Select(e=>e.i+1)))));Environment.Exit(0);}}IEnumerable<int> M(int[] v){var c=v.Last();var q=new{X=c/y,Y=c%y};return(from m in new[]{new{X=1,Y=2},new{X=2,Y=1}}from d in Enumerable.Range(0,4).Select(i=>new{X=(i&2)-1,Y=(i&1)*2-1})select new{X=q.X+d.X*m.X,Y=q.Y+d.Y*m.Y}into p where p.X>=0&&p.Y>=0&&p.X<x&&p.Y<y select p.X*y+p.Y).Except(v);}}}
```
This code finds a solution (if any) using brute force. Here's the ungolfed (and slightly refactored) version: <http://pastie.org/4149829>
**Input:** Modify the parameters in the `new P().K(...);` call.
**Output:** To the console, in the required format
**Online demos:**
Test Case 1 (3, 4): <http://ideone.com/UU9sw> (another solution than OP's, but it's a valid one)
Test Case 2 (2, 3): <http://ideone.com/ZX9xC>
A bigger board (4, 7): <http://ideone.com/QKuXL> *(this takes close to 5s to run, so retry if it fails the first time)*.
***Note:** Mono does not have the `String.Join` method overload that takes as a parameter an `IEnumerable<T>`, so in order to get this working on IdeOne I have to modify the code a bit (modify these `IEnumerable<T>`s to `string[]`).*
[Answer]
# Python, 316
Took about 30 minutes to run on input of `3 4`. I wouldn't try it on anything larger.
```
import itertools as I
r=range
x,y=map(int,raw_input().split())
m=[(a,b)for a in r(x)for b in r(y)]
q=[n for n in I.permutations(m,x*y)if all((abs(o[0]-p[0]),abs(o[1]-p[1]))in((1,2),(2,1))for(o,p)in zip(n,n[1:]))]
print'\n'.join(' '.join([`q[0].index(z)+1`for z in m][i:i+y])for i in r(0,x*y,y))if q else"NOT POSSIBLE"
```
I notice the other Python answers get input by doing `x,y=input()` rather than `x,y=map(int,raw_input().split())`, but the question does not allow for commas in the input so it seems the former method would fail. If the question does allow commas in the input, I'll shave an additional 20 characters off my answer.
I tried a recursive solution, but the best I could get was 334 characters:
```
r=range
x,y=map(int,raw_input().split())
m=[(a,b)for a in r(x)for b in r(y)]
o=[]
def f(m,x=0):
for n in m:
if x==0 or map(lambda x,y:abs(x-y),n,x)in([1,2],[2,1])and not o:
if len(m)==1 or f(m-{n},n)or o:o.append(n)
f(set(m))
print'\n'.join(' '.join([`o.index(z)+1`for z in m][i:i+y])for i in r(0,x*y,y))if o else"NOT POSSIBLE"
```
[Answer]
## Python, 370 367 366 338
Simple recursive solution. It isn't efficient, but works fast for example cases :-)
```
import itertools as I
P=I.product
a,b=input()
r=range;A=r(a);B=r(b);T={}
def S(x,y):
if 0<=x<a and 0<=y<b and(x,y)not in T:
T[x,y]=len(T)+1
for i,j in P((-2,2),(-1,1)):S(x+i,y+j);S(x+j,y+i)
if len(T)!=a*b:T.pop((x,y))
for q,w in P(A,B):S(q,w)
print"\n".join(" ".join(str(T[i,j])for j in B)for i in A)if len(T)==a*b else'NOT POSSIBLE'
```
[Answer]
## VBA 494 574 833 chars
Fixing to account for the transposed example added quite a bit of code...
I squeezed a little more out be shifting around some `If` checks to avoid using `End If`.
This now correctly handles `4, 5` and `5, 4`, but it takes impossibly long for `4, 7`, and I'm not 100% sure it works for that set.
```
Dim z,v,e,i,j,p,l
Sub k(a,b)
e=a*b:q:i=2
If c(a,b) Then z(e)=e:j=e+1
For i=1 To e:s=s & z(i) & IIf(i Mod b=0,vbCr,vbTab):Next
MsgBox IIf(j-1=e,s,"NOT POSSIBLE")
End Sub
Sub o()
z(l)=j:v(l)=1:p=l:i=p:j=j+1
End Sub
Sub u(r,t)
z(r)=0:v(r)=0:p=t:j=j-1
End Sub
Sub q()
ReDim z(1 To e),v(1 To e):z(e)=e:v(e)=1:p=1:z(1)=p:v(1)=p:j=2
End Sub
Function w(b)
f=(p-1) Mod b+1:m=(l-1) Mod b+1:g=Int((p-1)/b)+1:n=Int((l-1)/b)+1:w=(((f-2=m Or f+2=m) And (g-1=n Or g+1=n)) Or ((f-1=m Or f+1=m) And (g-2=n Or g+2=n)))
End Function
Function c(a,b)
t=p:m=i:
If i>1 And i<e Then
For h=1 To 8:l=p+Choose(h,(b-2),(b+2),(2*b-1),(2*b+1),-(b-2),-(b+2),-(2*b-1),-(2*b+1)):r=l:If l>1 And l<e Then If v(l)=0 Then If w(b) Then o:If j>=e Then l=j:If w(b) Then c=1 Else u r,t Else c=c(a,b):If c=0 Then u r,t
Next:End If
If c=(i>=e) Then i=m+1:c=c(a,b)
End Function
```
[Answer]
# [APL (Dyalog Extended)](https://github.com/abrudz/dyalog-apl-extended), 22 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?") ([SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set"))
```
⊃⌂kt,⍥⊆'NOT POSSIBLE'⍨
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNrShJzUtJTfn//1FX86OepuwSnUe9Sx91tan7@YcoBPgHB3s6@biqP@pd8T/tUduER719IHW9ax71bjm03vhR28RHfVODg5yBZIiHZ/D/NAVjBROuNAUjBWMA "APL (Dyalog Extended) – Try It Online")
`⊃` the first of…
`⌂kt` the first knights tour (if possible, else: an empty list)
`,⍥⊂` juxtaposed with
`'NOT POSSIBLE'⍨` the required fall-back value
] |
[Question]
[
**This question already has answers here**:
[Golf a mutual quine](/questions/2582/golf-a-mutual-quine)
(17 answers)
Closed 9 years ago.
Write a program in language A which outputs a program in language B where:
1. Language A != Language B
2. The output is itself a solution to this question.
This is a popularity contest. If you want to define your own BNFs/grammars for this, feel free, but try not to make it too boring by doing so.
EDIT: The more languages it ends up generating code in, the better (in my opinion).
EDIT2: Try to use languages that are not similar (I.e. generate the code in a different family of languages). (E.g. C to Scheme)
[Answer]
# php --> asp --> html --> xhtml .......
```
Hello
```
Infinite languages
[Answer]
## HQ9+, HQ9++ (and more)
```
Q
```
I'm starting to like this family of languages.
] |
[Question]
[
**This question already has answers here**:
[Convert radicals to mixed & entire radicals and to real numbers [closed]](/questions/18535/convert-radicals-to-mixed-entire-radicals-and-to-real-numbers)
(5 answers)
Closed 10 years ago.
Given integers a and b in the format a√b (a on the square root of b), make a program that will reduce b and increase a until the radical statement is fully simplified.
Example
```
input
a = 1
b = 16
output
4 root 1
```
In this instance, 1√16 = 4√1
Bonus - 25 chars for the ability to simplify radicals other than square root using another variable, c.
[Answer]
## Python, 71-25=46 63-25=38 chars
```
f=lambda a,b:max((a*i,b/i/i)for i in range(1,b)if b%(i*i)==0)
g=lambda a,b,c:max((a*i,b/i**c)for i in range(1,b)if b%i**c==0)
```
f is 61, chars. g is 63 but gets a 25 char bonus.
] |
[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 7 years ago.
[Improve this question](/posts/1798/edit)
Write a program to test if a string is palindromic, with the added condition that the program be palindromic itself.
[Answer]
## Ruby
```
z=gets;puts *z.reverse==z&&1||0||1&&z==esrever.z* stup;steg=z
```
Prints 1 if the input is a palindrome, 0 if it isn't. Input without linebreak.
Doesn't use any comments, instead it uses 2 tricks:
* Short-circuiting: `0` is true-ish in Ruby (only `nil` and `false` evaluate to false), so `1&&z==esrever.z* stup` isn't evaluated and thus can't raise a runtime exception
* The splat/multiplication operator (`*`): To avoid a syntax error in `z=esrever.z stup`, we force the parser to parse this as `z=esrever.z()*stup` by adding a `*`. On the other side, the `*` is parsed as a splat operator, which in a function call splits an array in a series of parameters. If there's only one element instead of an array, it basically does nothing, so `puts *foo` is equivalent to `puts foo`.
Obvious solution using comments (prints true/false):
```
puts gets.reverse==$_#_$==esrever.steg stup
```
[Answer]
**Python without comment**
```
"a\";w=]1-::[w trinp;)(tupni_war=w;";w=raw_input();print w[::-1]==w;"\a"
```
I'm surprised that no one found that trick yet, it should work in most languages!
[Answer]
## Perl
`perl -nle "$s=$_ eq+reverse;print$s;s$tnirp;esrever+qe _$=s$"`
no comment tricks, just cleverly abusing the substitution operator (hey, perl variables start with a $ too, so what?)
[Answer]
# Python 2.7
```
s=raw_input();print'YNEOS'[s!=s[::-1]::2]#]2::]1-::[s=!s['SOENY'tnirp;)(tupni_war=s
```
[Answer]
## C
```
#include <stdio.h> //
#include <string.h> //
int main() { //
char str[1024]; //
fgets(str, sizeof(str), stdin); //
int i = 0, j = strlen(str) - 2; //
for (; i < j; i++, j--) //
if (str[i] != str[j]) { //
printf("no\n"); //
return 0; //
} //
printf("yes\n"); //
} //
// }
// ;)"n\sey"(ftnirp
// }
// ;0 nruter
// ;)"n\on"(ftnirp
// { )]j[rts =! ]i[rts( fi
// )--j ,++i ;j < i ;( rof
// ;2 - )rts(nelrts = j ,0 = i tni
// ;)nidts ,)rts(foezis ,rts(stegf
// ;]4201[rts rahc
// { )(niam tni
// >h.gnirts< edulcni#
// >h.oidts< edulcni#
```
Running example:
```
$ gcc -std=c99 c.c && ./a.out
blahalb
yes
```
[Answer]
# Golfscript
```
.-1%=#=%1-.
```
* just with comment trick
* input without \n at the end
* perform matching char by char (even for punctuation)
* returns 1 for success, 0 for failure
[Answer]
# PHP
```
echo strrev($z)==$z;#;z$==)z$(verrts ohce
```
Facts:
* `$z` string, the input string to check
* `$t` boolean, TRUE if the input string `$z` is palindrome, FALSE otherwise
* Using comments to help me make the code palindrome.
* Outputs `$t`
* Source itself is a palindrome
The reason why it will not be possible to implement palindromic palindrome checker in PHP it's because PHP variables are named starting with a `$`. You cannot end an identifier name with `$` in PHP.
[Answer]
# PHP
```
<?php eval/*/*/(';{$i=fgets(STDIN,2e9);};{$a="strrev";}{var_dump("{$i}"=="{$a($i)}");}/*}{*\{;("{(tupni$)a$}"=="{putni$}")ohce}{;"verrts"==a$};{;(9e2,NIDTS)stegf=i$);');/*\*\eval php?>
```
Uses some odd tricks to avoid the `$` issue, technically isnt a palindrome as I had to sneak a `;` in at the end.
```
<?php $i = fgets(STDIN,2e9); echo $i == strrev($i);/*\;(i$)verrts == i$ ohce ;(9e2, NIDTS)stegf = $i php?>
```
This is a working one that uses PHP's `/* */` comments and the fact that you don't need the end for them.
[Answer]
# [Fuzzy Octo Guacamole](https://github.com/RikerW/Fuzzy-Octo-Guacamole), 17 bytes
```
^Cz.=i_;@;_i=.zC^
```
Not exactly sure how the win is defined, but I put the byte count up top.
`^` gets the input and pushes it to the first stack.
`C` copies the first stack to the second.
`z` reverse the top of the stack, so "as" becomes "sa".
`.` shifts the active stack, so the active stack has the input, and the inactive one has the reversed input.
`=` checks for equality, returning `0` for equality.
`i` inverts the ToS, so `0` becomes `1`, and anything else pretty much becomes `False`.
`_` pops and sets the temp variable which the `;` then prints.
`@` ends the program manually, so it doesn't hit the reversed part. This makes the palindrome.
[Answer]
## CoffeeScript
I actually struggled with the reverse spellings of 'split', 'reverse' and 'join' :\
```
p=(s)->s.split('').reverse().join('')==s#s==)''(nioj.)(esrever.)''(tilps.s>-)s(=p
```
[Answer]
## Groovy
```
print args[0]==args[0].reverse()?1:0//0:1?)(esrever.]0[sgra==]0[sgra tnirp
```
[Answer]
# Python 3, 55 bytes
Uses a comment, but is shorter than the other Python one that uses comments.
```
s=input();print(s==s[::-1])#)]1-::[s==s(tnirp;)(tupni=s
```
[Answer]
# Javascript
```
function a(b){return b==b.split('').reverse().join('')}//})''(nioj.)(esrever.)''(tilps.b==b nruter{)b(a noitcnuf
```
Hard to do it without comments...
] |
[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/2336/edit) so it's [on-topic](/help/on-topic) for Code Golf Stack Exchange.
Closed 12 years ago.
[Improve this question](/posts/2336/edit)
Below are a basic set of requirements.
---
The following commands (for an interface to the game):
```
attack <target>, <move>
goto <place>
buy <item>
enum <
targets,
moves,
places,
items,
stats
>
```
---
The following player stats:
* HP
* MP/SP (Mana/Stamina)
* XP
* Level
* Gold
* Items
---
## Scoring
(Thanks to @Casey for this idea.)
For each feature implemented, you gain 1 point. The post with the greatest number of points becomes the winner. In the event of a tie, the post with the highest number of votes becomes the winner. (In the event of a tie for *that*, the master of the dimensions [me] chooses.)
---
BONUS: Make it fun! Add something special.
]
|
[Question]
[
**This question already has answers here**:
[2048-like array shift](/questions/95409/2048-like-array-shift)
(51 answers)
Closed 4 years ago.
I have a fixed length vector of 4 elements. The inputs of which are always 0 or 2^n for n = 1 to 15 (so n = 0 excluded i.e. 2^0 = 1 will not appear)
`x = [32, 4, 4, 8]`
the result should be
`x = [32, 8, 8, 0]`
The way it works is that values that are the same will get combined, but one it's combined it can not be combined with another value for another turn.
and we want to simulate the shortest code to make simulate 2048 move left on this one row.
The shortest code wins! It's fixed-size 4 vector. So it's not the same as the other problem. Also, you need to put zeros here.
Test cases:
```
[0,0,0,0] -> [0,0,0,0]
[0,0,0,2] -> [2,0,0,0]
[2,0,0,4] -> [2,4,0,0]
[8,0,0,8] -> [16,0,0,0]
[16,16,32,64] -> [32,32,64,0]
[16,16,8,8] -> [32,16,0,0]
[2,2,2,0] -> [4,2,0,0]
```
[Answer]
# [J](http://jsoftware.com/), 31 bytes
```
4$!.0[:;_2([:<,`+@.=/)\ ::0-.&0
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/TVQU9QyirazjjTSirWx0ErQd9Gz1NWMUrKwMdPXUDP5rcqUmZ@QrGBuBkJkJSKeVQpqCoRkIgYUgCgygECwL40CkjDCljOBSJggpiDoTqBTQeCRtFmCmhQLcNVBpJMdYwKVNoEZBTQVBg/8A "J – Try It Online")
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 36 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")[SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set")
Anonymous tacit prefix function.
```
⎕UCS{4↑⍺⍺t⎕R(1⌽∪¨t←2/¨⍺⍺2*⍳16)⍺⍺⍵~0}
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT////1Hf1FDn4GqTR20TH/XuAqISoEiQhuGjnr2POlYdWlHyqG2Ckf6hFRBJI61HvZsNzTQhvEe9W@sMav@nAZU86u0D6vP0f9TVfGi9MciwvqnBQc5AMsTDM/h/moKBDhhywVhGQJYRmGUCZFmAWRZAlqGZDhAZG@mYmcB5FjoWCmDlIGgAAA "APL (Dyalog Unicode) – Try It Online")
`⎕UCS{`…`}` derived function where `⍵` is the argument and `⍺⍺` converts to/from code points:
`⍵~0` the argument without zeros
`⍺⍺` convert to code points
`t⎕R(`…`)` **R**eplace the texts `t` (defined below) with the corresponding texts from:
`⍳16` the indices from 1 to 16
`2*` two raised to the power of those
`⍺⍺` convert them to characters
`2/¨` make two of each
`t←` assign to `t`
`∪¨` get the unique element from each (i.e. deduplicate them)
`1⌽` cyclically rotate the first string to the end
`⍺⍺` convert to code points
`4↑` take the first four elements, padding with zeros
[Answer]
# Julia 277 248 bytes
```
m(x)=begin
t=true
e=falses(3)
for i in 2:4
if x[i]!=0
d=!t
for j in i-1:-1:1
if x[j]!=0
if(x[j]!=x[i])|e[j]
p=x[i]
x[i]=0
x[j+1]=p
d=t
break
elseif x[j]==x[i]
x[j],x[i]=x[i]*2,0
e[j]=t
d=t
break
end
end
end
if !d
x[1],x[i]=x[i],0
end
end
end
x
end
```
] |
[Question]
[
Your mission, even if you don't accept it, is to input three numbers from STDIN or file:
>
> 5 0.5 6
>
>
>
What you must do is evaluate this:
>
> (5a + 0.5b)^6
>
>
>
This basically means that the first two numbers are the coefficients of a and b and the third is the exponent in a binomial expansion.
Rules:
* The first two numbers are either integers or simple terminating fractions.
* The third number is a positive integer.
* Do not use any inbuilt binomial functions from libs. (thanks to comments)
* The shortest code wins!
Go on, do it.
[Answer]
## Mathematica 36
```
InputForm@Expand[(#1 a + #2 b )^#3] &
```
Usage
```
InputForm@Expand[(#1 a + #2 b )^#3] &[5, .5, 6]
```
Result:
```
15625*a^6 +9375.*a^5*b +2343.75*a^4*b^2 +312.5*a^3*b^3 +23.4375*a^2*b^4 + 0.9375*a*b^5 + 0.015625*b^6
```
[Answer]
F# 153 chars 156 bytes
```
let a,b,n=1.,2.,3
let rec C k=if k=0 then 1 else (n-k+1)*C(k-1)/k
List.iter(fun i->printf"%+ga^%ib^%i"(pown a (n-i)*pown b i*float(C i)) (n-i) i)[0..n]
```
[Answer]
# [Python 2](https://docs.python.org/2/), 144 bytes
```
a,b,n=input();f=lambda n:-~(n and~-n*f(~-n))
for k in range(-~n):print"+ "[0**k]+"%d*(%d*a^%d)*(%d*b^%d)"%(f(n)/f(k)/f(n-k),a**(n-k),n-k,b**k,k)
```
[Try it online!](https://tio.run/##JYtBCsIwEEX3nmIIFGbSBLXLSk8iChNiNESnJdSFm1w9pgr/Pd7mL5/1MctQKxtnZIqyvFekU5ie/HKeQUZbUIDFFys6YDPRLswZEkSBzHK/oS1C45KjrKoHdT5onS696rzGBl87T79yW6kOAwrtA6ZNYhMZ1vofTca1t0lU69FA2/AF "Python 2 – Try It Online")
[Answer]
### C (C99), 223 chars
```
#include <stdio.h>
#include <math.h>
int f(int n,int k){
return k==0?1:(n*f(n-1,k-1))/k;
}
int main(void){
float a,b;int n;
scanf("%f%f%d",&a,&b,&n);
for(int k=0;k<=n;k++)
printf("%d*(%fa)^%d*(%fb)^%d+",f(n,k),a,n-k,b,k);
puts("0");
}
```
Input:
```
1 1 2
```
Output:
```
1*(1.000000a)^2*(1.000000b)^0+2*(1.000000a)^1*(1.000000b)^1+1*(1.000000a)^0*(1.000000b)^2+0
```
] |
[Question]
[
A completely even number is a positive even integer whose divisors (not including 1) are all even.
Some completely even numbers are:
* 2 (divisors: 2, 1)
* 4 (divisors: 4, 2, 1)
* 16 (divisors: 16, 8, 4, 2, 1)
* 128 (divisors: 128, 64, 32, 16, 8, 4, 2, 1).
Some *non*-completely even numbers are:
* 10 (divisors: 10, 5, 2, 1)
* 12 (divisors: 12, 6, 4, 3, 2, 1)
* 14 (divisors: 14, 7, 2, 1)
* 18 (divisors: 18, 9, 6, 3, 2, 1)
* 1, being odd, is not completely even.
0 is not completely even (it's divisible by all positive integers, including odd numbers) but you **do not** need to handle this.
Your challenge is to take a positive integer as input and output a truthy value if it is completely even and a falsy value if it is not. These outputs do not need to be consistent.
If your solution doesn't return a falsy value for 0, it's encouraged to show what changes would be necessary to make it do so. Especially encouraged is to **show how your solution differs from checking if the input is a power of 2**; in some languages it may be shorter, and in some longer.
Input may be taken via any allowed method, and output may be given via any allowed method.
The shortest code in bytes wins!
[Answer]
# [MATL](https://github.com/lmendo/MATL), 2 bytes
```
qB
```
[Try it online!](https://tio.run/##y00syfn/v9Dp/39DAA "MATL – Try It Online")
### How it works
This takes advantage of MATL's convenient interpretation of truthy and falsy. `q` decrements the input and `B` gets the binary representation of the result. This yields a non-empty array of **1**'s (truthy) for even powers of two, an array that is either empty of contains a **0** (falsy) otherwise.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 2 bytes
```
Óg
```
[Try it online!](https://tio.run/##MzBNTDJM/f//8OT0//8NAQ "05AB1E – Try It Online")
In 05AB1E only `1` is truthy. Input-`1`-and-input-`0`-verified.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 3 bytes
```
^’>
```
[Try it online!](https://tio.run/##y0rNyan8/z/uUcNMu/8GRYYGBgYKh9sPT0hTiFR4uGP7o4Y5Cj6ZxSXFCok5OQrJ@bkFOaklqTmVCqllqXkKeaW5SalFxQpJqSXlqUC@gUJiXooCyAy9/wA "Jelly – Try It Online")
### How it works
```
^’> Main link. Argument: n
’ Decrement; yield n-1.
^ Compute the bitwise XOR of n and n-1.
This will conserve the highest set bit of n only if n is a power of two.
If n is even, n-1 will be positive and the result will be different from n.
> Test if the result is larger than n.
```
[Answer]
# [Python 3](https://docs.python.org/3/), 16 bytes
```
lambda n:n^n-1>n
```
Returns *True* or *False*.
[Try it online!](https://tio.run/##K6gsycjPM/5fUJSZV6KhlZaZU5JapPE/JzE3KSVRIc8qLy5P19Au77@OQlFiXnqqhqGBgYGmpuZ/AA "Python 3 – Try It Online")
### How it works
* If **n = 0**, then **n ‚äï (n - 1) = 0 ‚äï -1 = -1 < 0 = n**, so the function returns *False*.
* If **n = 1**, then **n ‚äï (n - 1) = 1 ‚äï 0 = 1 = n**, so the function returns *False*.
* If **2k < n < 2k+1**, then **2k ≤ n - 1 < 2k+1**, so **n** and **n - 1** have the **2k** bit in common,
**n ‚äï (n - 1) < 2k < n**, and the function returns *False*.
* Finally, if **n = 2k** with **k > 0**, then **n = 2k** and **n - 1 = 2k - 1** have no bits in common, so
**n ‚äï (n - 1) = n + (n - 1) > n + 0 = n** and the function returns *True*.
[Answer]
# Regex (ECMAScript or better), 17 bytes
`^((x+)(?=\2$))+x$` - Completely even
Takes its input in unary, as a string of `x` characters whose length represents the number.
**[Try it online!](https://tio.run/##Tc89b8IwFIXhv0IjBPeSJiQIdcA1TB1YGNqxtJIVLs5tjWPZBlI@fnsKQ6XOz5GO3i91UKHy7GIWHG/I7xr7TT@dl5aOvVfSL60DOMn5eNR9ArQpwkKuJ33EtO13o/EJ89i8Rc9WA@bBcEXw9JhNEUWQhTjWbAjASE9qY9gSID5IuzcGz1qaPDjDEYbZEAVvAazUuSGrY43zyeXCYaVWwNIpH2hpI@j34gPxD@g/2Hm5KGd3xlj75pgs7UEZ3vS8sppmvSQ1Ytt4EPwsSXCa4u0waZPckyMVgTHfqVjV4BHPYTBwt6QI94pSuH0M0d8m4nrtimxaFsUv "JavaScript (SpiderMonkey) – Try It Online") - ECMAScript
[Try it online!](https://tio.run/##TY5Na8JAEIb/igRhZ4hZEunJ7eqpBy8e2mNtcUnGOCXdpLOrBtTfnsZCwdsLz/v15U4ulMJdzHxb0RBsbsS@Uv3Sd/AWhX2txZ13wydAnyKs7HY@RUz76bDToeGSoJhlBaIR@jmyECghVzXsSaEuRx1p7SPJ3o3WC/vuGBedtCWFoEOs2N9Qtx7UX2LW2OWlto0OXcMRVKbQ8B7A21o35Ot4wOX8euWwcRtg2zkJ93ao3/MPxH9Aj8Avi1WxuGOMB2nPydqfXMPVRJyvaTFJ0sbsWwHDz5YMpymOg0mfaKFuPA@M@tvF8gCCeHk43h6jPgtHAggrtfVqoRSmjCbYwtxuOOTZU5Hnvw "JavaScript (Node.js) – Try It Online") - ECMAScript 2018**
[Try it online!](https://tio.run/##bVLbbtswDH3vV3BGh0i5qE6xp6lGsQ0bMGDthvYxzQDFlhOlMu1JcuOm6LdnlONdCtQvNMmjQ50jbtWDmm2L@4OpmtoF2FIuTC3GEv6vtMHYV2tOr3VHnZOmXVmTQ26V93ClDMITDDUfVKDwUJsCKuqw2@AMrkG5tV8sOYSNq3cePne5boKp6eQJwBdjNZQZ6l3/yxKR14UW1E@4/NiWpXa6uNGq0A5WPexlkf05OaQl53KY66dB7jaRnzGfrUiDKr4Z1IzzNxm21nJTMi/0r1ZZz5Kz8XiccP70EnpkYCy8SvBEDOEvAxGcEcOKcPfST7LRHY5iDPL5WHv@oULQDsFlwx@prZo4wHNJbqzq2mqFsM9KYtQSbnOFSNINNm2ADKLaocZuH33QlTDIJQw6e5jYKH@tu0DX7C0GGAyxdHfiOIKQEIPEob9YgqV2RAnfWBNYMqNHIHwATKnzFQOtgRONcl5TwuwiXfIp4PzVprAa12FzcQ6XEJHwnsJ8SYz5RrnFshv09BnOlxI@OKcevSiNtaybjrpRbwpAWbuoja6RYSoBLzKcU5hMSOCVCvmGHKqIzYnqmLF@c5EW/BORHzdG7Jxq2DAir5vH7@WNwrWmSekUOY9KS2AVjceCvItvu@eDyTU5tnMmaBYflct9Flwb3@dfuyEPQ8mStz4hS7h8jt9J3KrDT8a6CWeX2d35KeeT7vQQV@WQzt7N0/Q3 "Java (JDK) – Try It Online") - Java
Remarkably, there are *three* completely different 17 byte solutions for Powers of 2, which blew my mind even when I thought there were two. For this challenge, only one is 17 bytes, but for plain Powers of 2 they all are.
---
`^(?!(x(xx)+)\1*$)` - **17 bytes** - Powers of 2
`^(?!(x(xx)+)\1*$)x` - **18 bytes** - Powers of 2, correct at zero
`^(?!(x(xx)+)\1*$)xx` - **19 bytes** - Completely even
| Regex engine | Powers of 2 | Completely even |
| --- | --- | --- |
| ECMAScript | [Try it online!](https://tio.run/##Tc/LbsIwEIXhV4GogpmkCUmFusA1rLpgw6Jd9iJZZHCmNY5lG0i5PHsKi0pdf0c6@r/UXoW1Zxfz4Lgmv23tN/30Xlo6DF5IP3cO4Cjnk7T/hMUQOug6zPC9Su@wTydHLGL7Gj1bDVgEw2uCx/t8iiiCLMWhYUMARnpStWFLgDiUdmcMnrQ0RXCGI4zzMQreAFipC0NWxwbnD@czh5VaAUunfKCljaDfyg/EP6D/YOfVoprdGGPj20OytHtluB54ZTXNBklmxKb1IPhJkuAsw@th0iWFJ0cqAmOxVXHdgEc8hdHIXZMi3Coq4XYxRH@diMulr/JpVZa/ "JavaScript (SpiderMonkey) – Try It Online") | [Try it online!](https://tio.run/##Tc/LbsIwEIXhV4GoghnShKRCXeAaVl2wYdEue5EsGJxpjWPZBlwuz57ColLX35GO/i@1V2Hl2cUiOF6T37b2m346Ly0dei@kn5MDOMrZeNR9wrwPCVLCHN/r0R2m1I3GRyxj@xo9Ww1YBsMrgsf7YoIogqzEoWFDAEZ6UmvDlgCxL@3OGDxpacrgDEcYFkMUvAGwUpeGrI4Nzh7OZw5LtQSWTvlACxtBv1UfiH9A/8HO6nk9vTHGxreHbGH3yvC655XVNO1luRGb1oPgJ0mC8xyvh1nKSk@OVATGcqviqgGPeAqDgbsmRbhV1MLtYoj@OhGXS1cVk7qqfgE "JavaScript (SpiderMonkey) – Try It Online") |
| Python | [Try it online!](https://tio.run/##NY7BTsMwEETv@YrF6mG3TaIscEqw@iEhSBW4rZFZR2ujpl@f1kXcRvP0RjNf8znKy@p/5qgZ0jXV6urvFGUAtWqMWT9w/4QLLgvt6J23G1rv7ch9w9MA3nbVMSoE8FLsNuUvL30FwYY2zcFnNI2hCvwRghMM9PbcQxh5smHspgqKLEXWg5wceslYANV/iSfaMd33yoC6NrmDfp5RazCL2cqDFOR7mLUo9CgsD/9v4m9uL@qzw5QVhWjl5pW77gY "Python 3 – Try It Online") | [Try it online!](https://tio.run/##NY7BTsMwEETv@YrF6mG3TSIbOCVY/ZAQpArc1siso7VR3a9P6yJuo3l6o1mu@Rz5ZfU/S5QM6Zpace13ijyCWFFKrR@4f8KCpdCO3s12Q6Ws934yQ2fmEbzVzTEKBPBc/T7lL89DA8GGPi3BZ1Sdogb8EYJjDPT2PECYzGzDpOcGqsxVlgOfHHrOWAG1f8nMtDN036sD4vrkDvJ5RmlBFbXlB6nID7BIVehRWDP@v4m/ub@Izw5TFmSiVXevRusb "Python 3 – Try It Online") |
| Ruby | [Try it online!](https://tio.run/##PY5BiwIxDIXv/oo4LNgqE1rZW7eI4F73IHsbtSjWsVDi0KnYvfjXZ1tRDwnk5X0vCdfD3xBAw9q2NnVI9gar5e8Sg90fFTgtFNzOzlvwurWxHwG4E/imllutqw1VKi98IxDr@VaBpWN2ZAX7zrvIJvWEPxH0ltp4Zvxrnpkm8xl7I6dLAAJHUESMF@OYFByxGN9j9j2yWJWqKXHQdwiqCG5c/uyusX/klb9lnoOjCPQ6UXopY75/VsYMO7YYs8RS4jO@kdMPPgyy/pRC/AM "Ruby – Try It Online") | [Try it online!](https://tio.run/##PY5BiwIxDIXv/oo4LNgqE1rZW7eI4F73IHsbtSjWsVDi0KnYvfjXZ1tRDwnk5X0vCdfD3xBAw9q2NnVI9gar5e8Sg90fFTgtFNzOzlvwurWxHwG4E/imllutqw1VKi98IxDr@VaBpWN2ZAX7zrvIJvWEPxH0ltp4Zvxrnpkm8xl7I6dLAAJHUESMF@OYFByxGN9j9j2yWJWqKXHQdwiqCG5c/uyusX/klb9lnoOjCPQ6UXopY75/VsYMO7YYs8RS4jO@kdMPntIwiPpTCvEP "Ruby – Try It Online") |
This is what I came up to solve a level of [Regex Golf](https://alf.nu/RegexGolf) on 2014-02-21, and was also independently discovered by several others, including earlier than 2013-12-20. It's the one most similar to the well-known [primality test](https://codegolf.stackexchange.com/questions/57617/is-this-number-a-prime/177196#177196), which is probably why most people came up with this one instead of the others.
It asserts that \$n\$ has no odd divisors of \$3\$ or greater yielding a positive quotient. It has a false positive for zero, since although zero can be divided by any odd number, the quotient is zero, not positive. This can be fixed at the cost of an extra byte: `^(?!(x(xx)+|)\1*$)` or `^(?!(x(xx)+)\1*$)x`.
Since the entire test is inside a (negative) lookahead, it can be adapted to answer this challenge by adding `xx` at the end, which enforces that only \$n‚â•2\$ can match.
---
`^(?!(x*)(\1\1)+$)` - **17 bytes** - Powers of 2
`^(?!(x*)(\1\1)+$)xx` - **19 bytes** - Completely even
| Regex engine | Powers of 2 | Completely even |
| --- | --- | --- |
| ECMAScript | [Try it online!](https://tio.run/##Tc/LbsIwEIXhVwlRBTNJE5IKdYFrWHXBhkW7LK1kweBMaxzLNpdyefYUFpVYf0c6@r/VToWlZxeL4HhFftPaH/rtvLS0T95Ivx4cwFFOhln3BdMeHDKERb2oMX/ALhsesYzte/RsNWAZDC8Jnh@LEaIIshL7hg0BGOlJrQxbAsSetFtj8KSlKYMzHGFQDFDwGsBKXRqyOjY4eTqfOczVHFg65QPNbAT9UX0i/gPdg53U03p8Y4yNb/fpzO6U4VXildU0TtLciHXrQfCLJMF5jtfD9JCWnhypCIzlRsVlAx7xFPp9d02KcKuohdvGEP11Ii6XripGdVX9AQ "JavaScript (SpiderMonkey) – Try It Online") | [Try it online!](https://tio.run/##TY5PT8IwGMa/ChKTvq9jzWo8rRZOHrhw0KNoaLaX8ZrazbbAEuCzz2Fiwu1Jfs@/L3uwsQrcpdy3NQ3RFDqYV2pe@g7eUmDfyGCPm@ETFnfQPyCs1Vphdo99P2xkdFwRqFmuEHWgnz0HAhHI1o49CZTVqBMtfaKwtaP1xL7bp7ILbUUxyphq9heUrQfxl5g5Mz81xsnYOU4gcoGatwDeNNKRb9IO54/nM8eVXQGbzoZ4bYfmvfhA/Ad0C/xcLVR5xZh2oT1Ol/5gHdeTYH1D5WSaOb1tA2h@NqQ5y3AcnPZTGagbzwOj/Lap2kFAPN0cb/dJHgMnAogLsfaiFAIzRh2N0pcLDkX@pIriFw "JavaScript (Node.js) – Try It Online") |
| Python | [Try it online!](https://tio.run/##NY7BTsMwEETv@YrF4rDbJpFdbglWPyQNUgUuXWTW0doV7deHuojbaJ7eaJZbOSd5Wfl7SVog33Krof3KSUZQr8aY9Q33T3jdEB7cwdH2mdZ7O7mhc/MI7G1zSgoRWKrd5/LBMjQQfezzErmg6Qw1wCeIQTDS626AOLnZx8nODVRZqqxH@QzIUrACav@Sm2nr6L5XBzT0ORz1/YzagrmajTxIRTzAolWhR@Hd@P8mXUr/o1wC5qIoRKvtds7aXw "Python 3 – Try It Online") | [Try it online!](https://tio.run/##NY7BTsMwEETv@YrF4rDbJpFdbgkWH5IGqQKXLjLraG1E@vWhLuI2mqc3muVaLkmeNv5akhbI19xqaD9zkhHUqzFme8WXB1x3hEd3dLR/pHXdbv3khs7NI7C3zTkpRGCpfp/LO8vQQPSxz0vkgqYz1ACfIQbBSM@HAeLkZh8nOzdQZamynuQjIEvBCqj9S26mvaPbXh3Q0Odw0rcLagtmNTu5k4p4gEWrQvfCu/H/Tfou/Y9yCZiLohBttjs4a38B "Python 3 – Try It Online") |
| Ruby | [Try it online!](https://tio.run/##PY5Bi8IwEIXv/oqxLJgoHZJes2ER9LqHxVurQWmsgTCWNGL34l/vJrJ6mIF58743E26n3ymAhh/b2bFHsnfYrHdrDPbYKnBaKLhfnLfgdWfjMANwZ/B1KfdaFw0VKi18LRDLaq/AUpscScGh9y6yRbng/wh6S128MP5ZJaZOfMLeyPkagMARZBHj1TgmBUfMxveYfM8sVozFkjjoBwSVBTfPf/a3ODzz8t8yzcFRBHqdyD2XMdvvjTHTgX3N2bjkrJGN5KsPPk2irKQQfw "Ruby – Try It Online") | [Try it online!](https://tio.run/##PY5BawIxEIXv/RXjIpgoOyR7jUEEvXoove3aUDGugTAu2YjppX99m0jrYQbmzfveTLifvqcAGt5tb9OAZB@w235sMdivswKnhYLH1XkLXvc2jm8A7gK@reVR66qjSuWFbwVi3RwVWDpnR1ZwHLyLbFEv@B@C3lIfr4yvm8y0mc/YC7ncAhA4giJivBnHpOCIxfgas@@ZxapULYmD/oGgiuBm5c/hHsdnXvlb5jk4ikD/J0ovZcz@sDNm@mSbGUtLzjrZSb6a85SmSdSNFOIX "Ruby – Try It Online") |
This was discovered by Grimmy in 2019-02-05, [without fanfare](https://chat.stackexchange.com/transcript/message/48931239#48931239). I on the other hand was amazed, as this has no such flaw as the other negative assertion – it does not match zero.
It asserts that \$n\$ has no divisors yielding an odd quotient of \$3\$ or greater. As a negative assertion, it does not consume the power of 2 that it matches, and thus is great for use in larger regexes where it doesn't need to be wrapped in a lookahead to allow other tests to be done on the same value of \$tail\$.
The downside is that in standard regex engines, it's significantly slower than `^(?!(x(xx)+|)\1*$)`. In my regex engine though, they're both [statically optimized](https://github.com/Davidebyzero/RegexMathEngine/blob/master/matcher-optimization.h#L148) into a bitwise power of 2 test unless optimizations are disabled.
---
`^((x+)(?=\2$))*x$` - **17 bytes** - Powers of 2
`^((x+)(?=\2$))+x$` - **17 bytes** - Completely even
| Regex engine | Powers of 2 | Completely even |
| --- | --- | --- |
| ECMAScript | [Try it online!](https://tio.run/##Tc89b8IwFIXhv0IjBPeSJiQIdcA1TB1YGNqxtJIVLs5tjWPZBlI@fnsKQ6XOz5GO3i91UKHy7GIWHG/I7xr7TT@dl5aOvVfSL60DOMn5eNR9ArQpwkKuJ33EUdvvRuMT5rF5i56tBsyD4Yrg6TGbIoogC3Gs2RCAkZ7UxrAlQHyQdm8MnrU0eXCGIwyzIQreAlipc0NWxxrnk8uFw0qtgKVTPtDSRtDvxQfiH9B/sPNyUc7ujLH2zTFZ2oMyvOl5ZTXNeklqxLbxIPhZkuA0xdth0ia5J0cqAmO@U7GqwSOew2DgbkkR7hWlcPsYor9NxPXaFdm0LIpf "JavaScript (SpiderMonkey) – Try It Online") | [Try it online!](https://tio.run/##Tc89b8IwFIXhv0IjBPeSJiQIdcA1TB1YGNqxtJIVLs5tjWPZBlI@fnsKQ6XOz5GO3i91UKHy7GIWHG/I7xr7TT@dl5aOvVfSL60DOMn5eNR9ArQpwkKuJ33EtO13o/EJ89i8Rc9WA@bBcEXw9JhNEUWQhTjWbAjASE9qY9gSID5IuzcGz1qaPDjDEYbZEAVvAazUuSGrY43zyeXCYaVWwNIpH2hpI@j34gPxD@g/2Hm5KGd3xlj75pgs7UEZ3vS8sppmvSQ1Ytt4EPwsSXCa4u0waZPckyMVgTHfqVjV4BHPYTBwt6QI94pSuH0M0d8m4nrtimxaFsUv "JavaScript (SpiderMonkey) – Try It Online") |
| Python | [Try it online!](https://tio.run/##NY7BbsIwEETv@YqVxWEXkshOb0ktPiQECbWmGLnraG1E@PqAqXobzdMbzfzIl8gfq/@do2RIj1SLq68p8gBiRSm1HhGXHeHeHroN0XbZrK92NH1jpgG81dU5CgTwXOw25W/PfQXBhjbNwWdUjaIK/BmCYwz02fUQRjPZMOqpgiJzkeXEPw49ZyyA6r9kJtoZeu2VAXFtcif5uqDUoBa15TcpyPcwS1HoXVgz/L@Jt9zexWeHKQsy0aqbzmj9BA "Python 3 – Try It Online") | [Try it online!](https://tio.run/##NY7NasMwEITvfopF5LBb/yC5N7uiD@I4EFqlUVFXZqUQ5@mdKKG3YT6@YZZbPkd@3/zfEiVDuqVGXPObIo8gVpRS2wFxrQk/7b7fEdXrbnu0kxlaM4/gra5OUSCA52J3KX97HioINnRpCT6jahVV4E8QHGOgj36AMJnZhknPFRSZiyxH/nHoOWMB1LySmak29NgrA@K65I7ydUZpQK3qjZ@kID/AIkWhZ2HN@P8mXnJ3FZ8dpizIRJtue6P1HQ "Python 3 – Try It Online") |
| Ruby | [Try it online!](https://tio.run/##PY5BC8IwDIXv/oo4BFtlodu1FhH06kG8TS2KdRZKHF3FefGvz1bUQwJ5ed9L/P307D0o2JjadA2SecBysV2gN8ezBKuEhMfVOgNO1Sa0AwB7AVflxV6pbEeZjAtXCcS83EswdI6OqGDbOBvYOB/zL4LOUB2ujM/KyFSRj9gfudw8EFiCJGK4acsKwRGT8T9G3yeLZV02IQ7qBV4mwQ7Tn809tJ@89HcRZ28pAP1OpJ5K69V6qXV/YKybcjZXu3LE@aQb9b3Iy0KINw "Ruby – Try It Online") | [Try it online!](https://tio.run/##PY5BC8IwDIXv/oo4BFtlodu1FhH06kG8TS2KdRZKHF3FefGvz1bUQwJ5ed9L/P307D0o2JjadA2SecBysV2gN8ezBKuEhMfVOgNO1Sa0AwB7AVflxV6pbEeZjAtXCcS83EswdI6OqGDbOBvYOB/zL4LOUB2ujM/KyFSRj9gfudw8EFiCJGK4acsKwRGT8T9G3yeLZV02IQ7qBV4mwQ7Tn809tJ@89HcRZ28pAP1OpJ5K69V6qXV/YKybcjZXu3LE@bQb9b3Iy0KINw "Ruby – Try It Online") |
I discovered this one in 2014-02-21, after being mentally primed by solving teukon's Dominoes 2 puzzle (which is now included in [Regex Golf](https://alf.nu/RegexGolf)); teukon independently came up with it later that same day. It was the very first problem in unary that we solved by repeatedly decreasing \$tail\$ in a loop while retaining an invariant property at every step, and is probably the simplest function that is best golfed by being solved that way.
It repeatedly divides \$tail\$ by \$2\$ (asserting each time that there is no remainder) as many times as possible, and then asserts that the end result is \$1\$. This one is useful in larger regexes when it is desirable to consume the identified power of 2.
It is the most suitable for solving this challenge, “Is it a completely even number?”, as the only change necessary is upping the minimum iteration count of the loop from `0` to `1` by changing the `*` quantifier to a `+`, at a cost of 0 bytes. This enforces that \$n\$ must be evenly divided by \$2\$ at least once before yielding an end result of \$1\$.
[Answer]
# [Python 2](https://docs.python.org/2/), 18 bytes
```
lambda x:~-x&x<1<x
```
[Try it online!](https://tio.run/##K6gsycjPM/qfZhvzPycxNyklUaHCqk63Qq3CxtCm4n9BUWZeiUKaRmZeQWmJhqbmf0MA "Python 2 – Try It Online")
-3 thanks to [Rod](https://codegolf.stackexchange.com/users/47120/rod).
[Answer]
## JavaScript (ES6), 14 bytes
```
f=
n=>n>1>(n&n-1)
```
```
<input type=number min=0 oninput=o.textContent=f(this.value)><pre id=o>
```
Python doesn't have the monopoly on chained comparisons!
[Answer]
# [Husk](https://github.com/barbuz/Husk), 3 bytes
Returns `log‚ÇÇ(x)` if True `0` otherwise
```
£İ2
```
### Explanation
```
£ Is it an element of the increasing sequence
İ2 powers of two (starting at 2)
```
[Try it online!](https://tio.run/##yygtzv7//9DiIxuM/v//b2hkAQA "Husk – Try It Online")
[Answer]
# [Japt](https://github.com/ETHproductions/japt/), 6 bytes
```
õ!² øU
```
[Test it](https://ethproductions.github.io/japt/?v=1.4.5&code=9SGyIPhV&input=MQ==)
---
## Explanation
Generate an array of integers (`õ`) from `1` to input `U`. Raise 2 to the power of each (`!²`). Check if the array includes (`ø`) `U`.
[Answer]
# [Python 2](https://docs.python.org/2/), 33 bytes
```
lambda n:bin(n).count('1')==1-n%2
```
[Try it online!](https://tio.run/##K6gsycjPM/qfZhvzPycxNyklUSHPKikzTyNPUy85vzSvREPdUF3T1tZQN08VqCq/SCFTITNPoSgxLz1Vw9RA06qgKDOvRCFTJ00jU/M/AA "Python 2 – Try It Online")
## Recusive approach, ~~38~~ 36 bytes
-2 bytes thanks to Leaky Nun
```
f=lambda n:n>1if n<3else f(~n%2*n/2)
```
[Try it online!](https://tio.run/##BcFBCoAgEAXQq8wm0Agqo41UdzFyasC@Ym7adHV7L73lijC18hrcvR@OYLGNwoRl8uHxxOpDY1r0RleOmYQElB1Or@ZB25QFhaRjJbr@ "Python 2 – Try It Online")
[Answer]
# [Implicit](//git.io/sS), ~~7~~ ~~2~~ 3 bytes
```
½?ö
```
[Try it online!](https://tio.run/##K87MLchJLS5JTM7@///QXvvD2/7/NwQA) Explanation:
```
implicit float input
¬Ω calculate log2(input)
? if truthy
ö push 1 if top-of-stack is whole, 0 if non-whole
implicit int output
```
`½` pushes log2(input). If the input is `0` or `1` it will push `0.000000`. 0 is a whole number so performing `ö` on 0 will yield 1, giving the incorrect result for the input 1. `?` only performs the next command if the top of stack is truthy. So if the input was 1 or 0, it will skip the `ö` and print 0 as it's supposed to. Otherwise it will push 1 if `log2(input)` is whole and 0 if it's not.
[Answer]
# Regex ([Tcl ARE](https://www.tcl-lang.org/man/tcl/TclCmd/re_syntax.htm)), ~~24~~ 22 bytes
`^((x((xx)*))\2*$)\3` - **19 bytes** - Powers of 2 - [Try it online!](https://tio.run/##bVHbisIwEH33K46hD1YotC7sS7f7I5qFWscajGNJ4loo/fbutG5Flh3yMJk5l3ASKjt4CnDY@tveByR8ra6XS8kHP/b7sjp7W/oTTdfv0plyb@XSDV@rVSunjddxvNuso3j3NvQ6xywXnOEaruSaEDlk2FLbOHTzxhLX4SQrjQSbXuvFyDTIctxPxpIgawoePhwMw2osCyRZj24BqRFrrdg01gREFipRYm6OQrOztBXWJ9KZM/M4xdYaPlA7QpD@yysKjGYTPkPEokLW03PyqpDp/mlwvLpfzIPURYyPQvpRzXDlwK/vGWsyd1RLPkhE1VQSsESmniFSQ2WAmLFW@i99llhGRlbNTTJTqs8faaY5pol8HtNd3kxQEateakiT9zT9AQ "Tcl – Try It Online")
`^(x$|(x((xx)*))\2*$)\3` - **22 bytes** - Completely even - [Try it online!](https://tio.run/##bVHLboMwELznKyaWDxAJCVKpF0p/JHElQjbEqmOQ7TRIlG@nCylRVHVP6915rMahMqOnAIedvx58QGKbqrlcSnv0U38oq09vSn@m@flVOl0eDD/68SPq5HfURVHXxZs43m83Mt6/jIPKsSgGp20NV9qaIB0y7KhrHfplY8jW4cwrhQTbQanVxNTIctzO2hAjawoePhy1hVFYF0iyAf0KXBPWGLZpjQ6QBiIRbK5PTDOLtGHWO9KFs/Bsip3R9kjdBEH6L68oMJnN@AzSsgoZT4/Js0KmhofBqXG/mDuplxZvBfeTmraVg32@Z6rZ3FHN@SBhVV1xxhyZeIRILZUBbGaVUH/pi8Raal61V85MiCG/p5nmmCf8f5ZufDNBSCsGrjFNXtP0Bw "Tcl – Try It Online")
Tcl ARE has both positive and negative lookaheads, but neither backreferences nor captures can be done inside one. So seemingly, it would be impossible to match powers of 2 instead of non-powers, because all of the ECMAScript regexes use backreferences inside a lookahead. This challenge states "output a truthy value if it is completely even and a falsy value if it is not", so an inverted-logic regex, such as `^(x*)(\1\1)+$|^x$`, would not satisfy the rules.
But as it so happens, in Tcl ARE it seems that any group anchored on both sides (`^` at the beginning and `$` at the end, either inside or outside the group as long as it's adjacent to the parentheses) in all its alternatives will be treated as atomic (preventing the engine from doing the equivalent of backtracking into that expression if the pattern fails to match at a later point). This does not appear to be documented, but it can be exploited to emulate a negative match. The equivalent in engines that support atomic groups would be:
`^(?>(x((xx)*))\1*$)\2` - **21 bytes** - Powers of 2 - [Try it online!](https://tio.run/##XVBda8IwFH33V4QQaK6m2ha3IbHzZRsIYw/b3qwLtUttWU1DGqEg/vbuVva0h1zu1znn5tjKDuuNrSxhjqSELiiZE@v0UTltm7zQPFjMpxulqrzxqmhPtm60y3gGMntfdIEgAb4Sm@qoxwXjtfEdV@pl@/qsFAgSA1IisZzUplad9pzawun5IS9@vMOgmvpUeyoIXSar5er@IVndUZCTsnWc1WkkWZOWyN7xj8@n7RtIuJC65KzZdd412mAGYbxPU5oZCrjcnQ84wbaIRBjDiNe9bdpvzWlIBa5LxBft2fgRu04QtEMCjNFeTgi5KZu/mpl1eptjNpsBShN@c@iU@6LizAkUG@3SuedBHwhmAIBcxhNr0EXVjndJgl@JJRlrwoy8osz1n60c5PDFN4@857zvYQqQxVMGWTIMUZjEUfQL "PHP – Try It Online")
`^(?>(x\B((xx)*))\1*$)\2` - **23 bytes** - Completely even - [Try it online!](https://tio.run/##XVBdS8MwFH3frwgh0Nyt3doylZHVgaggiA/q2zpDV9O1mKUhzaAw9tvr7fDJh1zu1znn5tjaDuuNrS1hjmSELiiZE@vUQTpldVEqHizm042UdaG9LNujbbRyOc9B5O@LLghJgK/CpjyoccF4ZXzHpXx@eX2SEkKSAFIisZg0ppGd8pza0qn5vih/vMMgdXNsPA0JXaar5er2Ll3dUBCTqnWcNVksmM4qZO/4x@fjyxsIOJOm4kxvO@@0MphBlOyyjOaGAi53pz1OsB3GYZTAiFe91e234jSiIa4LxJftyfgRu04RtEUCjPFOTAi5Kpu/mpl1dp1jNpsBShN@dehY@LLmzIUoNtqlCs@DPgiZAQByHk9sQJV1O94lCH4lEWSsCTPigjKXf7ZyEMMX39zzPn/gvO9hCpAnUwZ5OgxxlCZx/As "PHP – Try It Online")
These in turn are based on the [17 byte ECMAScript regex](https://codegolf.stackexchange.com/a/222496/17216) `^(?!(x(xx)+)\1*$)`. The logic of the Tcl ARE version is to assert that the largest odd factor of \$n\$ is \$1\$. The "completely even" version additionally asserts than \$n\ne 1\$.
Even more strangely than the atomic grouping behavior, Tcl ARE apparently records the positions where word-boundary-match operators (`\m`, `\M`, `\y`, `\Y`) were used inside a capture group, and repeats them if that group is repeated via a backreference. So `^((x\Y((xx)*))\2*$)\3` (**21 bytes**) not only doesn't match \$1\$, but doesn't match \$2\$ either: [Try it online!](https://tio.run/##bVHLasMwELznKybChzhgsFPoxXX/oyQqOM7GEVU2RlIag/G3u2unDqF0D2K1Ow8xCpUdPAU4bP117wMSvlSX87nkgx/7fVl9eVv6E03X79KZcm/l0g2fq1W7@5CjjddxvNuso3j3MvQ6xywYnOEaruSaEDlk2FLbOHTzxhLX4SQrjQSbXuvFyDTIctxOxpIgawoePhwMw2osCyRZj24BqRFrrdg01gREFipRYm6OQrOztBXWO9KZM/M4xdYaPlA7QpD@yysKjGYTPkPEokLW02PyrJDp/mFwvLhfzJ3URYy3QvpRzXDlwM/vGWsyd1RLPkhE1VQSsUSmHiFSQ2WAmLFW@i99llhGRlbNVTJTqs/vaaY5pol8H9NN3kxQEateakiT1zT9AQ "Tcl – Try It Online") – and as a result, the 22 byte method has to be used instead.
Explanation for Powers of 2 (**19 bytes**):
```
^
( # Group an expression that is anchored to start at its
# beginning and to end at its end, thus telling the Tcl ARE
# regex engine to treat it as atomic, not backtracking into
# it if a subsequent match fails.
( # \2 = sum of the following, which will be the largest odd
# number that results in a match for what follows:
x # 1; tail -= 1
((xx)*) # \3 = any even number, including zero, trying the largest
# values first; tail -= \3
)
\2*$ # Assert that \2 divides tail; anchor to end of string
)
\3 # Now that the above match is locked in and won't backtrack,
# assert that \3 == 0, as no other value can match when
# tail == 0 (at the end of the string), thus asserting that
# \2 == 1, i.e. that the largest odd factor of N is 1.
```
For Completely even (**22 bytes**), an alternative of `x$` is inserted as the first choice. If \$n=1\$ and this alternative matches, it effectively acts like a boolean short-circuit operator – the powers of 2 test won't be done, and `\3` will not be set.
An alternative method to match powers of 2 is `^((x+?)((\2\2)*$))\3` (**20 bytes**): [Try it online!](https://tio.run/##bVHbboJAEH33K44bHqANCeCjpf0Q3SaII266jmR3rSaEb6cDFmOaztPszLlMzobaDp4CHDb@svMBKZ/r8@lU8d6P/a6qv7yt/JGm53flTLWz8uiGzzi@vX4kcbwttkXyEiXJdjX0eo1ZLzjDDVzFDSFyyLGhW@vQzRtL3ISjrDRSFL3Wi5FpkK9xPRpLgmwoePiwNwyrsSyR5j26BaRGrLVi01oTEFmoVIm5OQjNztJWWO/IZs7M4wwba3hPtxGC7F9eWWI0m/A5IhYVsp4ek2eFXPcPg8PZ/WLupC5ivJXSj2qGawd@vmesydxRI/kgFVVTS8ISmXqESC1VAWLGWum/9FliGRlZtRfJTKl@fU8zW2OayO8xXeVmgopY9VJDlq6KHw "Tcl – Try It Online") - this uses the same atomic grouping trick, but the logic is to assert that the smallest quotient from dividing \$n\$ by any odd number is \$n\$ (thus it's implied that the only odd divisor of \$n\$ is \$1\$). For "completely even" numbers this becomes `^(x$|(x+?)((\2\2)*$))\3` (**23 bytes**): [Try it online!](https://tio.run/##bVHLboMwELznKyaWD9AKCciR0n5I4kqEuMSqs0G20yBRvp0upERR1T2td@exGofajl4HOGz9Ze8DEjrX59OpooOf@n1Vf3pb@aOen1@VM9Xe8qMf36NOfkfd81scRbt8l8dPMo53m3FQBRbJ4Aw1cBU1GtIhw1Z3rUO/bKymJhx5pZAgH5RaTUyDrMD1aKxmZKODhw8HQ7AK6xJJNqBfgWvCWss2rTUB0kIkgs3NB9PsIm2Z9Yp04Sw8SrG1hg66myBI/@WVJSazGZ9BEqto6/V98qiQqeFu8HF2v5gbqZeEl5L7Sc1Q7UCP90w1mzvdcD5IWNXUHDJHJu4h6lZXAWxGSqi/9EViLQ2v2gtnJsRQ3NJMC8wT/kDSV75ZQ0gSA9eYJpv8Bw "Tcl – Try It Online") But this method is much slower than the primary one shown in this answer, and Tcl cannot even match \$n=64\$ within 60 seconds.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 5 bytes
```
Æf=2Ȧ
```
[Try it online!](https://tio.run/##y0rNyan8//9wW5qt0Yll////NwQA "Jelly – Try It Online")
Does ***NOT*** fail for `1`!
[Answer]
# [Java (OpenJDK 8)](http://openjdk.java.net/), ~~18~~ 16 bytes
```
i->i>1&(i&~-i)<1
```
[Try it online!](https://tio.run/##TY0xD4IwEIV3fsVNhBppwmYCMjiYODgxGocKlRyWtqFXEmLwr2MxDL7x3fe@68QoUmOl7prXgr01A0EXOk7YS77Lo//OEyr@9LomNHo9RrUSzsFVoIZ3BCGOBGEN5w0qLppkK4c9nIxRUugSLBxhwbTEMosTjD8psiJbgmudW/9QYb5ZRoMN9EGeVDSgbm93EEPr2PZrTTU5kj03nrgNCCmdWC6sVVNyYCz/cXM0L18 "Java (OpenJDK 8) – Try It Online")
[Answer]
# MATL, 4 bytes
Saved a byte thanks to [Luis Mendo](https://codegolf.stackexchange.com/users/36398/luis-mendo)!
```
Yf2=
```
**[Try it here.](https://matl.suever.net/?code=Yf2%3D&inputs=2&version=20.4.1)**
Returns `1` (or an array of several `1`s) for truthy and `0` or (the empty string) for falsy.
# How?
```
Yf2= % Full program.
Yf % Prime factors.
2= % All equal 2?
% Output implicitly.
```
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 5 bytes
```
q]2{P
```
**[Verify all the test cases.](https://pyth.herokuapp.com/?code=q%5D2%7BP&test_suite=1&test_suite_input=1%0A2%0A4%0A16%0A128%0A10%0A12&debug=0)**
Alternative:
```
q2s{P
```
# Explanation
```
q]2{P ~ Full program with implicit input (Q) at the end.
P ~ Prime factors.
{ ~ Deduplicated.
q ~ Equals?
]2 ~ The literal [2].
~ Output (implicitly).
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~37~~ ~~33~~ ~~27~~ 18 bytes
Thanks to @MD XF for the idea
```
f(n){n=(n^n-1)>n;}
```
[Try it online!](https://tio.run/##HcjNCkBAEADg@zzFptRMOFBcBk8ipdVopwzJTZ59/XzHzxeL9zEKGl3WoY1WlNQb31EZ1ikYElzgXrIdqF3J2lZ1w5pl9PcniENBJXL7EewUTNJ5sCRXYrghPg "C (gcc) – Try It Online")
[Answer]
# JavaScript, ~~14~~ 11 bytes
-3 thanks to Deadcode
```
f=
n=>!(n&n-2)
// test numbers 0-16
const tests = [f(0), false, true, false, true, false, false, false, true, false, false, false, false, false, false, false, true]
const results = tests.map((res, n) => res === f(n))
document.write(
results.every(res => res)
? "All tests passed üòä"
: [
"Tests failed üò¶",
...results.map((res, n) => !res && `f(${n}): expected ${tests[n]}`).filter(Boolean),
].join("<br />")
)
```
```
body{font-size:3rem;font-family:monospace}
```
Explanation - this uses [this trick](https://stackoverflow.com/a/1053594/1903116) for checking if `n` is a power of 2, but uses `n&n-2` instead of `n&n-1` to make 1 return false
[Answer]
# Regex (Java / Perl / PCRE / .NET), 12 bytes
`^(\1\1|^x)*x$` - **13 bytes** - Powers of 2
`(\1\1|^x)+x$` - **12 bytes** - Completely even
| Regex engine | Powers of 2 | Completely even |
| --- | --- | --- |
| Java | [Try it online!](https://tio.run/##bVJdb9swDHzvr@CMDZHSRHXWt6nGsA0bMGDthvYxTQHFlhOlMu1JcuO062/PKMf7KBC/0CRPR92JG/Wgppvifm@qpnYBNpQLU4uxhP8rbTD2aM3ple6oc9K0S2tyyK3yHi6VQXiCoeaDChQealNARR12E5zBFSi38vMFh7B29dbD5y7XTTA1nTwB@GKshjJDve1/WSLyutCC@gmXH9uy1E4X11oV2sGyh70ssj8nh7TkXA5z/STI7TryM@azJWlQxTeDmnH@KsPWWm5K5oX@2SrrWXI2Ho8Tzp9eQg8MjIWjBE/EEP4yEMEZMSwJdy/9aTa6xVGMQT4fas8/VAjaIbhs@CO1VRMHeC7JjWVdW60QHrOSGLWEm1whknSDTRsgg6h2qLGbnQ@6Ega5hEFnDxNr5a90F@iavcUAgyGW7k4cBxASYpA49OcLsNSOKOEbawJLpvQIhA@AKXW@YqA1cKJRzmtKmJ2nCz4BnB1tCqtxFdYXb@E9RCS8ozBbEGO@Vm6@6AY9fYazhYQPzqmdF6WxlnWTUTfqTQEoaxe10TUyTCXgRYYzCqenJPBShXxNDlXE5kR1yFi/uUgL/onIDxsjtk41bBiR183ue3mtcKVpUjpBzqPSElhF47Eg7@LbPvLB5Joc2zoTNIuPyuVjFlwb3@dfuyEPQ8mSNz4hS7h8jt9J3Kr9Hbud3c5@3XV83L3exzXZp9Pz8zRNfwM "Java (JDK) – Try It Online") | [Try it online!](https://tio.run/##bVLbbtswDH3PV3DGhki5qE6fhqnGsA0bMGDdhvYxzQDFlhO1Mu1JcuO067dnlONdCsQvNMmjQ50j3qp7Nb8t7g6mamoX4JZyYWoxkfB/pQ3Gnqw5vdEddUZNu7Ymh9wq7@FSGYRHGGo@qEDhvjYFVNRh18EZ3IByG79ccQhbV@88fOxy3QRT08kRwCdjNZQZ6l3/yxKR14UW1E@4fN@WpXa6uNKq0A7WPex5kf05OaQl53KY62dB7raRnzGfrUmDKr4Y1IzzFxm21nJTMi/0z1ZZz5KzyWSScP74HHpkYCycJHgkhvCXgQjOiGFNuDvpp9n4BscxBvl0rD19VyFoh@Cy4Y/UVk0c4LkkN9Z1bbVCeMhKYtQSrnOFSNINNm2ADKLaocau9z7oShjkEgadPUxslf@qu0DX7C0GGAyxdHfiOIKQEIPEob9cgaV2RAnfWBNYMqdHIHwATKnzGQOtgRONcl5TwuwyXfEZ4OJkU1iNm7C9OIe3EJHwhsJiRYz5Vrnlqhv09BkuVhLeOaf2XpTGWtbNxt24NwWgrF3URtfIMJWAFxkuKEynJPBShXxLDlXE5kR1zFi/uUgL/oHIjxsjdk41bBiR183@W3mlcKNpUjpDzqPSElhF47Eg7@LbPvDB5Joc2zkTNIuPyuVDFlwb3@dfuyEPQ8mSVz4hS7h8it8obtWB3SxuFr9@dHzavTzELTmk89fnafob "Java (JDK) – Try It Online") |
| Perl | [Try it online!](https://tio.run/##RY7NasMwEIRfZQlLrG1sLKX0UlmpA@m1p97qRCQhBoGauJILLqr66q7iBnpZdmZ/5utOzj6M71@ATkKwl@PeApYySVVt1q/rVYT24hh6xWW1khTAtElR6Jw59zBrzjMZobbKd9b0LCuy3H8efJ9OdF6IXNDp47r09O/y5NMjapLXXz4l7l1tqyWF2r6JrUqVb@Ut19wkmkpN49QtFhRMC4xlQwYDpCUiUD9QoispoJ/PJ7iJLYEL@ceKRsYYtX5@2Wg97lgjGvG9G@huwHHkhbhfcs5/AQ "Perl 5 – Try It Online") | [Try it online!](https://tio.run/##RY5fS8MwFMW/ymVc1lza0mQgiGlmB/PVJ9/sDHOsEMi2mlSoxPjVa1YHvlzuOffP@fVHZ@@m0xegkxDs5bC3gJVMUtXbzctmHaG7OIZecVmvJQUwXVIUemfOAyza80JGaKzyvTUDy8qs8J/vfkgnuihFIej4cV16/Hd58ukBNcnrL58S966x9YpCY1/FTqXKd/KWa24STa3mcerynILpgLFszGCEtEQE6gcqdBUF9MvlDDezJXAh/1jRyBij1k/PW60n1opWfL@NlI84Tby8X3H@Cw "Perl 5 – Try It Online") |
| PCRE | [Try it online!](https://tio.run/##XVBda8IwFH33V4QQaKKptuo2JBZftoEw9rDtzWqoXWrDYhrSCAW3397dyp72kMv9OufcHFe7fr1xtUPEowzhGUZT5Lw6Sa@cKUpFo9l0vJGyLkyQZXN22iif05yJ/G3WRhxF8CpoypMaFmxQNrRUyufty5OUjKOUASUQi5G2WrYqUOxKr6bHovwKHoI0@qwD5ggv56vl6v5hvrrDTIyqxlOis0QQk1XA3tL3j8ftKxPsinRFidm1wRtlIWNxus8ynFvMYLm9HGECbZ7wOGUDXnXONJ@K4hhzWBeAL5uLDQN2PQfQDgggJnsxQuimbP9qYtfZbQ7ZZMJAGtGbQ@cilDUlnoPYYJcqAo26iBPLGEPX4UTNVFk3w10CwVdSgYYaESt@QObnn62Uif5A8zRPvw8dG3ek75M4XSySJPkF "PHP – Try It Online") | [Try it online!](https://tio.run/##XVDLasMwELznK4QQWGrkxDbpIygml7YQKD20vcWpcFw5FlVkIStgSPPt7jr01IOWfc3MalzjhtXaNQ4Rj3KE5xjNkPPqIL1ypqwUjeazm7WUTWmCrNqj00b5ghZMFG/zLuIogldDUx7UuGCDsqGjUj5vXp6kZBylDCiBWEy01bJTgWJXeTXbl9V38BCk0UcdMEd4kS0Xy7v7bHmLmZjUradE54kgJq@BvaPvH4@bVybYGemaErPtgjfKQsbidJfnuLCYwXJ32sME2jzhccpGvOqdab8UxTHmsC4AX7UnG0bsKgPQFgggJjsxQeiqbP9qYlf5dQ7ZdMpAGtGrQ8cyVA0lnoPYaJcqA436iBPLGEPn8UTNVNW0410CwVdSgcYaESsuIHP5ZytlYqBFWqQ/nz2b9mQYkvghS5Jf "PHP – Try It Online") |
| .NET | [Try it online!](https://tio.run/##RY9Ra4MwFIX/SpALJnUpcX1rCBT23F9gLYi7nYH0RmKKUpvf7nRj7PE7HD7O6f2IYejQuQWCqQJ@4VQfj4QjP@XLlV/KS/m6TmI3wZKf3rIPf@@tw89MaHgapW8@YNN2HByzxMBS/4hihsaAk0PvbMxkpu2NQ7Nv/YOidJG9b4XCQFOpOq0CDmQqS7H@STSQdPjH5cZFIebNEfbnJrYdDjyf8h2Q@I2fYh6DjSg7P8S0zir1PzNJfn3jLCEDSiktSh4OSqlv "PowerShell – Try It Online") | [Try it online!](https://tio.run/##RY/RaoQwFER/JcgFk9oscZ/KhsBCn/sFroVg79ZA9kZiFmVtvt1qS@njGYbDzBAmjGOP3q8QTRPxE@f2dCKc@Llc@aW@1F/vs6hmWMvzc/EaboPz@FEIDQ@j9DVEtF3PwTNHDBwN9yQWsAa8HAfvUiEL7a4c7KELd0rSJ3bcC5UB26g2bwIOZBpHqf1JNJD0@Mf1zlUllt0RD282dT2OvJzLJyDxGz/EMkWXUPZhTHmbVet/ZpLCdsY7QgaUc16VfDkq9Q0 "PowerShell – Try It Online") |
Subtracts increasing powers of 2 from \$tail\$, starting with \$1\$. As such, the sum of the subtracted powers will be \$2^a-1\$ where \$a\$ is the number of iterations so far. Once the loop has matched as many iterations as it can, asserts that the remaining \$tail=1\$.
Unlike the ECMAScript regexes, this needs to do no backtracking, thus is orders of magnitude faster in standard regex engines.
As with the 17 byte ECMAScript regex, it is quite suitable for solving this challenge, as the only change necessary is upping the minimum iteration count of the loop from `0` to `1` by changing the `*` quantifier to a `+`, at a cost of 0 bytes. But an added bonus here is that the first iteration of the loop can only match at the beginning of the string, so we can remove the first `^` anchor to save 1 byte. This does make the regex much slower in most regex engines though.
# Regex (Java / Perl / PCRE / Python[`regex`](https://github.com/mrabarnett/mrab-regex) / Ruby / .NET), 22 bytes
`^((?=(\3\3|^x))(\2))*x$` - **23 bytes** - Powers of 2
`((?=(\3\3|^x))(\2))+x$` - **22 bytes** - Completely even
| Regex engine | Powers of 2 | Completely even |
| --- | --- | --- |
| Python `import regex` | [Try it online!](https://tio.run/##NY5BasMwEEX3PsUguphJbSPFi4Ad0YPYDoRWSVSUsRmp1IHe3Y1cuhvm8R5/fqTbxM3q7/MkCeIjluKubik/48QdiBWl1HpCfLM4NEPzc1qIcNgT7ZaX9cl601Zm7MBbXVwmgQCec6aO6cNzW0CwoY5z8AlVpagAf4HgGAMd9y2E3ow29HosIMucZTnz1aHnhBlQ@XeZkV4NPXs5sE2sozvL@w2lBLWoHW8wU9/CLNmi7WFN9z9o@kr1t/jkMCZBJlp1ZQ5a618 "Python 3 – Try It Online") | [Try it online!](https://tio.run/##NY7RSsQwEEXf@xVD8GHGbUuy9ak1@CFthUWzu5E4KZOIXfDf66bi2zCHc7jLLV8jd5v/XKJkSLdUi7u4tf5IkQcQK0qpDfHF4tRN3c/rSoTTkeiwPmx3NJq@MfMA3urqHAUCeC6VNuV3z30FwYY2LcFnVI2iCvwZgmMM9HzsIYxmtmHUcwVF5iLLiS8OPWcsgOq/y8x0MHTvlcC@sE3uJG9XlBrUqh55h4X6HhYpFu0Pa4b/QfErt9/is8OUBZlo082T0foX "Python 3 – Try It Online") |
| Ruby | [Try it online!](https://tio.run/##PY5Bi8IwEIXv/oqxCCZCh7QePMQggl49yN5aDYqxBsJY0ohdWPzr3UR2PczAvHnfm/GP8/fgQcHeNKZvkcwTNuuvNXpzukiwSkh43qwz4FRjQjcCsFdwVV4clMpqymRcuEog5uVBgqFLdEQFu9bZwKb5lP8h6Aw14cb4soxMFfmIfZDr3QOBJUgihru2rBAcMRk/Y/S9s1jWZzPioF7gZRLsOP3ZPkL3zkt/F3H2lgLQ/4nUU2m93W20Ho6MrRSr5/X859hzzuqS81k/GQaRFwshxC8 "Ruby – Try It Online") | [Try it online!](https://tio.run/##PY5Bi8IwEIXv/oqxCCa7dEjrRciGRdCrB9lb6wbFWANhLGnECuJfr4nsepiBefO@N@Mv@9vgQcHGNKZvkcwVloufBXqzO0iwSki4nqwz4FRjQjcCsEdwVV5slcpqymRcuEog5uVWgqFDdEQFu9bZwKb5lP8h6Aw14cT4VxmZKvIReyPHswcCS5BEDGdtWSE4YjK@x@h7ZbGszz6Ig3qAl0mw4/RnewndKy/9XcTZWwpA/ydST6X1ar3UemDsW7F6Vs/uvz3nrC45/@wnwyDyeSnEEw "Ruby – Try It Online") |
This is a direct port of the 13 byte / 12 byte regex. Ruby, and Python's `regex` module, do not support nested backreferences, so they must be emulated via forward-declared backreferences. (Python's `re` module doesn't even support the latter.) The 13 byte version of this is faster than the 17 byte regexes, but golf-wise, they win.
Although this results in a fast regex that's compatible with six different engines, the [recursive solutions](https://codegolf.stackexchange.com/a/259835/17216) provide the best golf for Python's `regex` module and Ruby.
### \$\large\textit{Full programs}\$
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 18 bytes
```
.+
$*
(\1\1|^.)+.$
```
[Try it online!](https://tio.run/##Dcg5CoAwAEXB/p0jQjQQ/FlcTuAlgmhhYWMhlt49OuXcx3Nee23sslXvMB22qOhdfeu8qbVHBCKJzMDIxIz@FAooooQyGj4 "Retina 0.8.2 – Try It Online")
Takes its input in decimal. Uses the Java/Perl/PCRE/.NET pure regex.
# [Perl 5](https://www.perl.org/), 24 bytes
```
say 1x<>~~/(\1\1|^.)+.$/
```
[Try it online!](https://tio.run/##RU7NasMwGHuVb8YQm/w0GesOjROyS0YPu@ywS9sNE5zF4NjGDrSjS497gD3iHmRpaBm7CAkJSVY4tZy0gT13Wup3D4E4WOFkL/TA1Wrle@6Gng9NF@RgrNCkjlC5RjSHfSeVIKykx6Yzvc0rVXir5ECCOIjw25yQLfENV9xVit3SY6U22a6YMd2N0BpHsLyqHEtWXNyZhSE9ev4BNWA5jtAo4wWp6f86u6xXD8@PLwVao78jN8K0hFK4viFYFawu56B1Ug@AVYTg5@sbUD7N7XhzYOXptCDbbJt9viY0TPBiGqc0vr/7NXaQRvspflomaZaeAQ "Perl 5 – Try It Online")
[Answer]
# Regex (PCRE1), 11 bytes
`^(x(?1)?x|x)$` - **13 bytes** - Powers of 2
`^(x(?1)?x)$` - **11 bytes** - Completely even
| Regex engine | Powers of 2 | Completely even |
| --- | --- | --- |
| PCRE1 | [Try it online!](https://tio.run/##hVPbbtpAEH3nKya0CetgIrtIVWXjRGlK1QeaVIhIrQi1XLOGVc3aWq8LSeDXS2d37cS5SLX8sJczZ86cmY3zvLeI4/0bxuO0nFMY5LGgJ8vTVryMBIT5dAYBjNsf1@vfv/rlj9vb75Pl@/WS7H@SDTlzrbPNdmO93VvPAW0bjvMgzLuu33okL@ScZYq9eSQYXzw9Yxme0mj1EnfaYlxCjksZUiEyQeKMFxK02uMVLYpoQa17zON5MQJgMIDqVC31OeXz1AdBZSk4uP5OU64ixokF9y3AL59itpRykls9dxY4PpSI6b8LJWRqpwIWuNBgzWnU4UVeSh@Uh3AsqA9NdSgnl8JEC1qUqTRrVUeSFFTakJUS0y7k0txkf2gsMzHtz0wqZA00eRhnq5yllOQ2fLsYD8NPV5Pz0Qi2Znc9@fzBhiOT0CzqDI5lqFgC5EBQq/Yh0Z4mBKtBtA1tRaSlCYhQiQ6Hw7kHh8UNx@42OE2eijjBAKLE3ymntDkLKlPGKTFdYdw2Plk@Ytzacy0Kw7iDNUYyY0SDTuIQvSWWZQN3bcizAq/NTcL4nHR6nSqx@rirDELMQdDsi@dxdXj2Ci90Nb4LKMTD5I9cpmkqHadrs5tyt@vOfJyoFRZOChs6m44ShqUUeDkLGvEPRrCAq5kZBNz1odtlzYpNV9Us1J2lGxoTQW24vB6NbMAcDLum/2ocbOg3Sq6bWbGcBuDAdluTog96Iobj8dU4vLz6ej65@PJcQE1xZwE6oyolnRveMf3xX0BNG3FU1Yti/qtUVfoBijk6@o@YJ3xtD4Zq6NpPeXevO9aw2yB2LT2ynhlFQSkqsR4ee/XqWru903Ndx/kbJ2m0KPa9VFn/Dw "C++ (gcc) – Try It Online") | [Try it online!](https://tio.run/##hVNtb5swEP6eX3HN1sY0pIJFmiYIrbqu0z5k7RSl0qY0Q4wYYo0YZMySvuSvLzvb0NIXaYgP9r0899xz57goBmkc794wHmfVgsKoiAU9Wh534mUkICxmcwhg0v24Xv/@Nax@3Nx8ny7fr5dk95NsyIlrnWystzvrubtrw2ERhEXf9TuP0KVcsFxht02C8fSpjeVopdHqZdxxh3EJBR5lSIXIBYlzXkrQXA9XtCyjlFp3WMfzYgyA0QhqqzpqO@WLzAdBZSU4uP5WQ64ixokFdx3Ar5hhtYxyUlgDdx44PlQYM3wXSsjVTSWkeNDBGtOwQ0dRSR@UgnAoqA9tdkinkMJkC1pWmTRn1UeSlFTakFcSy6ZyaTz5HxrLXMyGc1MKUQMNHsb5qmAZJYUN384m5@Gny@npeAz35nY1/fzBhgNT0ByaCo5loFgCZE9Qq9Eh0ZomBLvBaBu6CkhTExAhE50O@wsP9strjtNtYZo6NXCCCUSRv1VKaXFSKjPGKTFTYdw2Olk@xriN5poUpnEHe4xkzogOOopD1JZYlg3ctaHIS3QbT8L4gvQGvbqw@rirBMKYvaA9F8/jynjyCi70dXwfkIiHxR@xzNBUOU7X5jbjbt@d@7hRK2yclDb0Nj1FDFsp0TkPWvkPQrCAq50ZBdz1od9n7Y7NVNUuNJOlGxoTQW24uBqPbcAaDKem/3odbBi2Wm6GWaMcB@DA/X0DijrojTifTC4n4cXl19Pp2ZfnBBqIWwtQGdUp6V3znpmP/yLUjBFXVb0o5r8KVZcfIZmDg/@QeYLX9eBcLV33Ke72dcVacpuIbUevrGdWUVCKTKyHx16/us525wxc13H@xkkWpeVukCnp/wE "C++ (gcc) – Try It Online") |
I'm not sure when this recursive regex was originally discovered. It was likely an accidental discovery, when someone tried to match palindromes and found that due to PCRE1's atomic subroutine calls, words consisting of only one distinct letter would only match when their length was a power of 2.
Explaining why this works is complicated, but I do intend to do it sometime.
This regex is absolutely phenomenal at being ported to this challenge; it loses 2 bytes in doing so.
# Regex (Perl / PCRE), 15 bytes
`^x(x(?1)?+x|x|)$` - **16 bytes** - Powers of 2
`^x(x(?1)?+x|x)$` - **15 bytes** - Completely even
This is a port of the PCRE1 regex to engines that may have non-atomic subroutine calls.
| Regex engine | Powers of 2 | Completely even |
| --- | --- | --- |
| Perl | [Try it online!](https://tio.run/##RY5fa8IwFMW/ykWCzaUtTYS9LI2t4F598m1zwQ0LgUxrUiEjxq9eYyfs5XLPuX/Orz9Y8zL@/AKxAoI5fe8NkEokKev1artaRuhOlhInmaiXAgPoLikMvdXHAWYfx5mI0BrpeqMHmpVZ4S5fbkgnqih5wfFwfiw1/y5LPr4SheLxy6XEvW1NvcDQmne@k6mynXjm6qckupbTOHV5jkF3QGnmM/CQlhBB3qAitsJA3Hw@wU1sCZyLP1aiRYxRqbfNWqnx01NPG45N7q/@imQcWbngjN0B "Perl 5 – Try It Online") | [Try it online!](https://tio.run/##RY5fa8IwFMW/ykWCzaUtTYS9mMZWcK8@7W1zwQ0Lgag16SAji1@9i1Xw5XLPuX/Orz9Y8zIef4FYAcGcv/cGSCWSlPVm/bZeRejOlhInmahXAgPoLikMvdWnAWYfp5mI0BrpeqMHmpVZ4X6@3JBOVFHyguPhcltqni5LPi6JQnH75VLi3ramXmBozTvfyVTZTjxy9UMSXctpnLo8x6A7oDTzGXhIS4ggr1ARW2Egbj6f4Ca2BM7FnZVoEWNU6nW7UWr89NTThmOT@z@PZBxZueCM/QM "Perl 5 – Try It Online") |
| PCRE1 | [Try it online!](https://tio.run/##hVNdb9owFH3nV9yytThNqMiQpikhrbqOaQ@snRCVNlEWseAEa8GxHDNoC3997NombfohLcqDP@4959xzrxMh2lmS7N4wnuTLGYWeSCQ9mZ82kvlUQizGE4hg2Py4Wv3@1V3@uL39Ppq/X83J7uearMmZ75y5681647zdOc9jmh4ciygWrh82HvFLNWOFJqgfScazp2eswFM6XbyMO20wrkDgUsVUykKSpOClAiP4eEHLcppR5x55giDBAOj1YH@ql@ac8lkegqRqKTn44dZALqaMEwfuG4CfGCNbTjkRTtufRJ0QlhjTfRcrKPROJ2S4MMEG06rDC7FUIWgb4VjSEOrqUI5Q0mZLWi5zZde6jjQtqfKgWCqkzdTc3hR/aKIKOe5OLBWiRgY8ToqFYDklwoNvF8N@/OlqdD4YwMburkefP3hwZAntomLoOBaKpUAOJHUqH1LjaUqwGoz2oKmBjDQJU1Ri0uFwFsBhecOxuzVMy7MHTjGBaPF32iljTkZVzjgltiuMe9YnJ8QYv/LciMI03sEap6pgxASdJDF6SxzHA@57IIoSr@1NyviMtNqtPbH@uK8NwpiDqN6XIOD68OwVXHBNvAsoJEDyRyzbNE3H6cruxtx3/UmIE7XAwknpQWvd0sKwlBIvJ1Et/8EIFnE9M72I@yG4LqtXbLuqZ6HqLF3ThEjqweX1YOABcjDsmvn34@BBt1Zy1cw9ymkEHdhsKlD0wUxEfzi8GsaXV1/PRxdfnguoIO4cQGd0paR1w1u2P@GLUNtGHFX9olj4KtSevodijo7@I@YJXjOAvh665lPc7euO1ey2EduGGdnAjqKkFJU4D499/@oa212n7fudzt8kzadZuWvn2vp/ "C++ (gcc) – Try It Online") | [Try it online!](https://tio.run/##hVNdb9owFH3nV9yytThNqMiQpikhrbqOaQ@snRCVNlEWseAEa8GxHDNoC3997NombfohLcqDP84999xzrxMh2lmS7N4wnuTLGYWeSCQ9mZ82kvlUQizGE4hg2Py4Wv3@1V3@uL39Ppq/X83J7uearMmZ75y5683aebtznkOaHhyLKBauHzYe6Us1Y4Xmrx9JxrOnZ6zAUzpdvMSdNhhXIHCpYiplIUlS8FKB0Xu8oGU5zahzj3mCIEEA9HqwP9VLc075LA9BUrWUHPxwaygXU8aJA/cNwE@MMVtOORFO259EnRCWiOm@ixUUeqcDMlwYsOG06vBCLFUI2kU4ljSEujqUI5S00ZKWy1zZta4jTUuqPCiWCtNmam5vij80UYUcdyc2FbJGhjxOioVgOSXCg28Xw3786Wp0PhjAxu6uR58/eHBkE9pFlaHjWCqWAjmQ1Kl8SI2nKcFqEO1BUxMZaRKmqMSEw@EsgMPyhmN3a5w2z544xQCixd9pp4w5GVU545TYrjDuWZ@cEDF@5bkRhWG8gzVOVcGIAZ0kMXpLHMcD7nsgihKv7U3K@Iy02q19Yv1xXxuEmIOo3pcg4Prw7BVecA3eBRQSYPJHLts0nY7Tld2Nue/6kxAnaoGFk9KD1rqlhWEpJV5Oolr8gxEs4npmehH3Q3BdVq/YdlXPQtVZuqYJkdSDy@vBwAPMwbBr5t@PgwfdWslVM/cspxF0YLOpSNEHMxH94fBqGF9efT0fXXx5LqCiuHMAndGVktYNb9n@hC@gto04qvpFsfBVqn36Hoo5OvqPmCd8zQD6euiaT3m3rztWs9sitg0zsoEdRUkpKnEeHvv@1TW2u07b9zudv0maT7Ny18619f8A "C++ (gcc) – Try It Online") |
| PCRE2 | [Try it online!](https://tio.run/##XVBda8IwFH33V4QQaO5stS1uQ2LpyzYQxh62vVkXapfasJqGNEJB/e3uVva0h1zu1znn5tjGXle5bSxhjmSEzimZEevUXjpl27JSPJjP7nIpm7L1suoOVrfKFbwAUbzP@yAkAb4am3KvxgXjlfE9l/Jl/fosJYQkAaREYjHRRsteeU5t5dRsV1Y/3mGQrT5oT0NCF@lysXx4TJf3FMSk7hxnOosFa7Ma2Xv@8fm0fgMBJ6JrztpN712rDGYQJdsso4WhgMv9cYcTbIdxGCUw4tVg2@5bcRrRENcF4qvuaPyIXaUI2iABxngrJoTclM1fzcwqu80xm04BpQm/OXQofdVw5kIUG@1SpefBEITMAAA5jSdqUFXTjXcJgl9JBBlrwoy4oMzln60cxPVr4APPE8inw3k4A7te4yhN4vgX "PHP – Try It Online") | [Try it online!](https://tio.run/##XVBdS8MwFH3frwgh0FzXbm2ZyshKX1QYiA/q2zpDV9M12KUhzaAw/e31dvjkQy7365xzc2xjx01uG0uYIxmhS0oWxDp1lE7ZtqwUD5aLm1zKpmy9rLqT1a1yBS9AFK/LPghJgK/GpjyqacF4ZXzPpXzaPj9KCSFJACmRWMy00bJXnlNbObU4lNWXdxhkq0/a05DQVbpere/u0/UtBTGrO8eZzmLB2qxG9p6/vT9sX0DAheias3bXe9cqgxlEyT7LaGEo4HJ/PuAE22EcRglMeDXYtvtUnEY0xHWB@Ko7Gz9hNymCdkiAMd6LGSFXZfNXM7PJrnPM5nNAacKvDp1KXzWcuRDFJrtU6XkwBCEzAEAu04kaVNV0012C4FcSQaaaMCN@UObnn60cxPgx8IHnCeTz4XsANo5xlCZx/As "PHP – Try It Online") |
# Regex (PCRE / Ruby), 16 bytes
`^x(x\g<1>?+x|x|)$` - **17 bytes** - Powers of 2
`^x(x\g<1>?+x|x)$` - **16 bytes** - Completely even
This is a port of the PCRE1 recursive regex to Ruby's subroutine call syntax.
| Regex engine | Powers of 2 | Completely even |
| --- | --- | --- |
| PCRE1 | [Try it online!](https://tio.run/##hVNdb9owFH3nV9yytTglVGRI05QQqq7rtAfWTohKmyiLWHCCteBYjjNoC3997NombfohLcqDP@4959xzr2MhOmkc794wHmflnEJfxJKeLAaNeDGTEInJFEIYNT@uVr9/9coft7ffx4v3qwXZ/VyT9U3a9wan7fVmvXHe7pznQU0XjkUYibYXNB4JCjVnuWaoH0nG06dnLMdTOlu@jBs0GFcgcKkiKmUuSZzzQoFRfLykRTFLqXOPPL4fYwD0@7A/1UtzTvk8C0BSVUoOXrA1kMsZ48SB@wbgJybIllFOhNPxpmE3gBJjeu8iBbne6YQUFybYYFp1eCFKFYD2EY4lDaCuDuUIJW22pEWZKbvWdSRJQZULeamQNlULe5P/obHK5aQ3tVSIGhrwKM6XgmWUCBe@nY8uok9X47PhEDZ2dz3@/MGFI0toFxVD17FQLAFyIKlT@ZAYTxOC1WC0C00NZKRJmKESkw6Hcx8OixuO3a1hWp49cIIJRIu/004Zc1KqMsYpsV1h3LU@OQHGeJXnRhSm8S7WOFM5IyboJI7QW@I4LnDPBZEXeG1vEsbnpNVp7Yn1xz1tEMYchPW@@D7Xh6ev4ELbxLcBhfhI/ohlm6bpOF3Z3YR7bW8a4EQtsXBSuNBat7QwLKXAy2lYy38wgoVcz0w/5F4A7TarV2y7qmeh6ixd05hI6sLl9XDoAnIw7Jr59@PgQq9WctXMPcoghC5sNhUo@mAm4mI0uhpFl1dfz8bnX54LqCDuHEBndKWkdcNbtj/Bi1DbRhxV/aJY8CrUnr6PYo6O/iPmCV7Thws9dM2nuNvXHavZbSO2DTOyvh1FSSkqcR4e@/7VNba7bsfzut2/cZLN0mLXybT1/wA "C++ (gcc) – Try It Online") | [Try it online!](https://tio.run/##hVNdb9owFH3nV9yytTglVGRI05QQqq7rtAfWTohKmyiLWHCCteBYjjNoC3997NombfohLcqDP@4959xzr2MhOmkc794wHmflnEJfxJKeLAaNeDGTEInJFEIYNT@uVr9/9coft7ffx4v3qwXZ/VyT9U3a9wan7fVm7bzdOc9jmi4cizASbS9oPOIXas5yTVA/koynT89Yjqd0tnwZN2gwrkDgUkVUylySOOeFAiP4eEmLYpZS5x55fD/GAOj3YX@ql@ac8nkWgKSqlBy8YGsglzPGiQP3DcBPTJAto5wIp@NNw24AJcb03kUKcr3TCSkuTLDBtOrwQpQqAG0jHEsaQF0dyhFK2mxJizJTdq3rSJKCKhfyUiFtqhb2Jv9DY5XLSW9qqRA1NOBRnC8FyygRLnw7H11En67GZ8MhbOzuevz5gwtHltAuKoauY6FYAuRAUqfyITGeJgSrwWgXmhrISJMwQyUmHQ7nPhwWNxy7W8O0PHvgBBOIFn@nnTLmpFRljFNiu8K4a31yAozxKs@NKEzjXaxxpnJGTNBJHKG3xHFc4J4LIi/w2t4kjM9Jq9PaE@uPe9ogjDkI633xfa4PT1/BhbaJbwMK8ZH8Ecs2TdNxurK7Cffa3jTAiVpi4aRwobVuaWFYSoGX07CW/2AEC7memX7IvQDabVav2HZVz0LVWbqmMZHUhcvr4dAF5GDYNfPvx8GFXq3kqpl7lEEIXdhsKlD0wUzExWh0NYour76ejc@/PBdQQdw5gM7oSknrhrdsf4IXobaNOKr6RbHgVag9fR/FHB39R8wTvKYPF3romk9xt687VrPbRmwbZmR9O4qSUlTiPDz2/atrbHfdjud1u3/jJJulxa6Taev/AQ "C++ (gcc) – Try It Online") |
| PCRE2 | [Try it online!](https://tio.run/##XVBdS8MwFH3frwgh0MSlW1umMrK6FxUG4oP6ts7Q1XQNZmlIMyi4/fZ6O3zyIZf7dc65Oa5xw2rtGoeIRznCc4xmyHl1kF45U1aKRvPZzVrKpjRBVu3RaaN8QQsmird5F3EUwauhKQ9qXLBB2dBRKZ83L09SMo5SBpRALCbaatmpQLGrvJrty@o7eAjS6KMOmCO8yJaL5d19trzFTEzq1lOi80QQk9fA3tH3j8fNKxPsB@maErPtgjfKQsbidJfnuLCYwXJ32sME2jzhccpGvOqdab8UxTHmsC4AX7UnG0bsKgPQFgggJjsxQeiqbP9qYlf5dQ7ZdMpAGtGrQ8cyVA0lnoPYaJcqA436iBPLGEM/44maqappx7sEgq@kAo01IlZcQObyz1bKxPDZ0744rNKH9bQ/92dGhiGJszRJfgE "PHP – Try It Online") | [Try it online!](https://tio.run/##XVBdS8MwFH3frwgh0MSlW1umMrK6FxUG4oP6ts7Q1XQNZmlIMyjM/fZ6O3zyIZf7dc65Oa5xw2rtGoeIRznCc4xmyHl1kF45U1aKRvPZzVrKpjRBVu3RaaN8QQsmird5F3EUwauhKQ9qXLBB2dBRKZ83L09SMo5SBpRALCbaatmpQLGrvJrty@o7eAjS6KMOmCO8yJaL5d19trzFTEzq1lOi80QQk9fA3tH3j8fNKxPsjHRNidl2wRtlIWNxustzXFjMYLk77WECbZ7wOGUjXvXOtF@K4hhzWBeAr9qTDSN2lQFoCwQQk52YIHRVtn81sav8OodsOmUgjejVoWMZqoYSz0FstEuVgUZ9xIlljKHzeKJmqmra8S6B4CupQGONiBUXkLn8s5UyMXz2tC8Oq/RhPe1/ekaGIYmzNEl@AQ "PHP – Try It Online") |
| **Ruby** | **[Try it online!](https://tio.run/##PY5BawIxEIXv/RXTpWBi2SHZa4wi2GsPxdtqg2JcA2FcshFTEP/6NpHWwwzMm/e9mXDZ/4wBNHzZzqYeyV5htVwvMdjdQYHTQsH15LwFrzsbhxcAdwTf1nKrdbWhSuWFbwVi3WwVWDpkR1Zw6L2LbFJP@B@C3lIXT4zPmsy0mc/YEzmeAxA4giJiPBvHpOCIxfgcs@@RxapUTYmDvkNQRXCv5c/@EodHXvlb5jk4ikD/J0ovZczH58qY8TuxtOlmcr54T7d042/jKGrZCPEL "Ruby – Try It Online")** | **[Try it online!](https://tio.run/##PY5BawIxEIXv/opxKZi07JDsNaZFsNceirfVBsW4BsK4ZCOmUPzrayLWwwzMm/e9mXDe/Y4BNHzbzqYeyV5guVgtMNjtXoHTQsHl6LwFrzsbhwmAO4Bva7nRulpTpfLCtwKxbjYKLO2zIys49N5FNqtn/IGgt9TFI@PzJjNt5jP2RA6nAASOoIgYT8YxKThiMT7H7LtnsSpVr8RBXyGoIrhp@bM/x@GeV/6WeQ6OItD/idJLGfP5tTRm/Eksrbu5fP94S3@Jv4yjqGUjxA0 "Ruby – Try It Online")** |
# Regex (Perl / PCRE2 / Boost / Python[`regex`](https://github.com/mrabarnett/mrab-regex)), 15 bytes
`^x(x((?1))\2|)$` - Powers of 2
`^x(x((?1)?)\2)$` - Completely even
| Regex engine | Powers of 2 | Completely even |
| --- | --- | --- |
| Perl | [Try it online!](https://tio.run/##RY5fa8IwFMW/ykWCzcWWJoW9LI1WcK8@@TZdcMNCINMu6aAjxq/eXTthL5d7zv1zft3Ju6fx8weYVxDd5ePogJWKpK436916maC9eM6CFqpeKoxgW1IYO2/PPcz255lK0DgdOmd7nhVZHr7fQ08nJi9kLvH0dV9a/buCfHxmBtX9V6DEo29cXWFs3Ks8aKrioB659iGZrfU0pm6xwGhb4DwbMhiAlhBB36BkvsTIwnw@wU1sBC7VHyuzKqVkzMt2Y8z4NvCB85VE3FdXZOMoikoK8Qs "Perl 5 – Try It Online") | [Try it online!](https://tio.run/##RY7NasMwEIRfZQlLrCU2lgy9RFbsQHrtqbcmFWmJQaAkjuSCi1Bf3VXcQC/LzuzPfP3J2afp/A3oJAR7/TxawFImqerd9nW7idBdHUOvuKw3kgKYLikKvTOXARb7y0JGaK3yvTUDy4os918ffkgnOi9ELuh0uy81/y5PPq1Rk7z/8inx6FpbVxRa@yYOKlV@kI9c85BoajWPU7daUTAdMJaNGYyQlohA/UCJrqSAfrmc4Wa2BC7kHysaGWPU@vllp/X0PrKRsUZQQ/uKcJp4UQnOfwE "Perl 5 – Try It Online") |
| PCRE2 | [Try it online!](https://tio.run/##XVBdS8MwFH3frwgh0FyXbm2ZysjKXlQYiA/q2zpDV9M12KUhzWAw/e31dvjkQy7365xzc1zjhtXaNY4wT3JC55TMiPP6oLx2bVlpHs1nN2ulmrINquqOzrTaF7wAWbzO@0iQCF@NTXXQ44IN2oaeK/W0eX5UCgRJASmRWE6MNarXgVNXeT3bl9VX8BhUa44mUEHoIlsulnf32fKWgpzUnefM5IlkbV4je8/f3h82LyDhQkzNWbvtg2@1xQzidJfntLAUcLk/7XGCbZGIOIURr8@u7T41pzEVuC4RX3UnG0bsKkPQFgkwJjs5IeSqbP9qZlf5dY7ZdAooTfjVoWMZqoYzL1BstEuXgUfnSDALAOQynmhAV0033iUJfiWVZKwJs/IHZX7@2cpBDh9nfuZ8nQIU2TewYUjiLE2SXw "PHP – Try It Online") | [Try it online!](https://tio.run/##XVDNa4MwFL/3rwhBMG@NrUq3UVLxsg0KY4dtt9oF62KVpTHEFITSv909y0475PG@fh95trHjJreNJYEjGaFLShbEOnWUTlldVoqFy8VdLmVTai@r7mRbrVzBChDF@7IPOQnx1diURzUtGK@M75mUL9vXZymBkwSQEonFrDWt7JVn1FZOLQ5l9eMdBqnbU@spJ3SVrlfrh8d0fU9BzOrOsaDNYhHorEb2nn18Pm3fQMCFtDUL9K73TiuDGUTJPstoYSjgcn8@4ATbPOZRAhNeDVZ334rRiHJcF4ivurPxE3aTImiHBBjjvZgRclM2f3VgNtltjtl8DihN2O1Cp9JXDQscR7HpXKr0LBxCHhgAIJfJYguqarrJlyD4lUSQqSaBEVeUuf47KwMxfg1sYCxPIIcCfY1jHKVJHP8C "PHP – Try It Online") |
| **Boost** | **[Try it online!](https://tio.run/##dVNtb5swEP6eX3HLpsYu0EIq7QOEVpq0PzDtw6Y0RdRxwFpiLGOUl61/vdnZNIxmxB/A9/bcPXdnplRQMHb8KCRbN0sOs@eqqs2t5gXf3ZRK3Y/OTXzHuDKikrdLkRcSVYJlQq4qvcmtuo1iZa4hU/MFpPBt/GW7/fV81/zc7398Lz9vS3J82pEdIQ8RpY/TP/TTkZ67jH24VmmmvCjplSAwneb55n4kpIFNLiSh8HsEeNQcTWsuiaJBtEjDBBr0uZtmBior2YDCXmqzjGP0FbJApWpM4uJZJWsDjmMcO/6gOYIlJ12N/FgJ2zJ/i0DKQCzsIQ19OPAOvOBmLSQnTmBC@m0empxqtccGyhDbk5tKEOdwwzKsi1Dqg4x8UFWN5tayEnJJJsGEJh2AjNBqfT6kfU5xLK3yYQAXPOfvQUQhxuT/sNy4rm06ybetNJeRFy0S2PBNzQ2pfZjsJrYw7EiNRtviLr5rhUil7fUslVECnif6jO0xen@mcb1YAel3Pqt5rllJSI8XvbJZA7Hw3Qh8nA6lA1gnvAMFpG6pkMmjxMbhmKJk0L2dU9UYmM1A/O/zMrosMbcU5N32dE8ErrjW9ALh4QLPirGfcQxfta70OBnG4RRWFsnB@BbAZk3sRnZ4qOnjje3/rdrhZ0wcxgXi7a39am4aLQGX4eUYBtE0DF/Zap0X9TFYuwyZG@lf "C++ (gcc) – Try It Online")** | **[Try it online!](https://tio.run/##dVNtb5swEP6eX3HLpsYu0EIq7QOEVpq0PzDtw6Y0RdRxwFpiLGOUl61/vdnZNIxmxB/A9/bcPXdnplRQMHb8KCRbN0sOs@eqqs2t5gXf3ZRK3Y/OTXzHuDKikrdLkRcSVYJlQq4qvcmtuo1iZa4hU/MFpPBt/GW7/fV81/zc7398Lz9vS3J82pEdIQ8R/UMfp/TTkZ67jH24VmmmvCjplSAwneb55n4kpIFNLiSh8HsEeNQcTWsuiaJBtEjDBBr0uZtmBior2YDCXmqzjGP0FbJApWpM4uJZJWsDjmMcO/6gOYIlJ12N/FgJ2zJ/i0DKQCzsIQ19OPAOvOBmLSQnTmBC@m0empxqtccGyhDbk5tKEOdwwzKsi1Dqg4x8UFWN5tayEnJJJsGEJh2AjNBqfT6kfU5xLK3yYQAXPOfvQUQhxuT/sNy4rm06ybetNJeRFy0S2PBNzQ2pfZjsJrYw7EiNRtviLr5rhUil7fUslVECnif6jO0xen@mcb1YAel3Pqt5rllJSI8XvbJZA7Hw3Qh8nA6lA1gnvAMFpG6pkMmjxMbhmKJk0L2dU9UYmM1A/O/zMrosMbcU5N32dE8ErrjW9ALh4QLPirGfcQxfta70OBnG4RRWFsnB@BbAZk3sRnZ4qOnjje3/rdrhZ0wcxgXi7a39am4aLQGX4eUYBtE0DF/Zap0X9TFYuwyZG@lf "C++ (gcc) – Try It Online")** |
| **Python `import regex`** | **[Try it online!](https://tio.run/##NY7BasMwEETv/opF5LDb2kZyb3ZFPsR1ICRKoqKuzEqlDvTfncilt2Eeb5j5nm@R31b/NUfJkO6pFnd1S/2ZIg8gVpRS62HBBXFviD66X9qtz240fWOmAbzV1SUKBPBc9Dbls@e@gmBDm@bgM6pGUQX@AsExBnrvegijmWwY9VRBkbnIcuSrQ88ZC6D6L5mJXg0998rAdq1N7iinG0oNalEvvMFCfQ@zFIu2wprh/1D8zu2P@OwwZUEmWnVjOq0f "Python 3 – Try It Online")** | **[Try it online!](https://tio.run/##NY7BasMwEETv/opF5LDb2kZyb3ZFPsR1ICRKoqKuzEqhztc7kUtvwzzeMPMj3yJ/rP5njpIhPVIt7uqW@jtFHkCsKKXWw4IL4t7Qnr462q2vbjR9Y6YBvNXVJQoE8Fz0NuWz576CYEOb5uAzqkZRBf4CwTEG@ux6CKOZbBj1VEGRuchy5KtDzxkLoPovmYneDb32ysB2rU3uKKcbSg1qUW@8wUJ9D7MUi7bCmuH/ULzn9ld8dpiyIBOtujGd1k8 "Python 3 – Try It Online")** |
I discovered this recursive regex on 2022-07-18 while working on
[Sum of Powers of 2](https://codegolf.stackexchange.com/questions/179174/sum-of-powers-of-2/250059#250059). It relies on subroutine calls being atomic.
```
^ # tail = N = input number
x # tail -= 1
( # Define subroutine (?1)
x # match += 1; tail -= 1
((?1)) # \2 = match made by recursive call; match += \2; tail -= \2
\2 # match += \2; tail -= \2
| # or
# Match nothing, causing a cascading pop to the top level of
# recursion, ending the match.
)
$ # Assert that we've reached the end of the string.
```
This is similar to `^(\1\1|^x)*x$`, in that the `(?1)` subroutine call will always return \$2^a-1\$ where \$a\$ is the depth of recursion it reached. This is why an extra \$1\$ is subtracted at the beginning (it could just as easily be done at the end, but that would be slightly slower due to backtracking).
It is very easily ported to solving this challenge; the first iteration at which it has a choice of whether to match nothing just has to be pushed down one level, at a cost of 0 bytes.
# Regex (PCRE2 / Ruby), 16 bytes
`^x(x(\g<1>)\2|)$` - Powers of 2
`^x(x(\g<1>?)\2)$` - Completely even
| Regex engine | Powers of 2 | Completely even |
| --- | --- | --- |
| PCRE2 | [Try it online!](https://tio.run/##XVBdS8MwFH3frwgh0FyXbm2ZykjrXlQYiA/q2zpDV9O12KUhzWAw99vr7fDJh1zu1znn5tjaDunK1pYwRzJC55TMiHV6r5y2bVFqHsxnNyul6qL1quwOtmm1y3kOMn@b94EgAb4Km2qvxwXjtfE9V@p5/fKkFAgSA1IisZw0plG99pza0unZrii/vcOg2ubQeCoIXSTLxfLuPlneUpCTqnOcNVkkWZtVyN7z94/H9StIOJOm4qzd9N612mAGYbzNMpobCrjcH3c4wbaIRBjDiNcn23ZfmtOQClyXiC@7o/EjNk0QtEECjNFWTgi5Kpu/mpk0u84xm04BpQm/OnQofFlz5gSKjXbpwvPgFAhmAICcxxMb0GXdjXdJgl@JJRlrwoy8oMzln60c5PB54iee79P4AfLkB9gwRGESR9Ev "PHP – Try It Online") | [Try it online!](https://tio.run/##XVDNS8MwFL/vrwgh0MSlW1umMtK6iwoD8aDe1hm6mq7BLA1pBoXh315fhycPebyv30eea92Yb1zrEPGoQHiJ0QI5r47SK2eqWtFoubjZSNlWJsi6OzltlC9pyUT5tuwjjiJ4DTTlUU0LNigbeirl8/blSUrGUcqAEojFTFstexUodrVXi0NVfwcPQRp90gFzhFfZerW@u8/Wt5iJWdN5SnSRCGKKBth7@v7xuH1lgl2Qbigxuz54oyxkLE73RYFLixks9@cDTKDNEx6nbMKrwZnuS1EcYw7rAvB1d7ZhwuYZgHZAADHZixlCV2X7VxObF9c5ZPM5A2lErxc6VaFuKfEcxKZzqSrQaIg4sYwxdJksaqbqtpt8CQRfSQWaakSs@AGZn39npUyMnwMdaHnM04cNK8HYOCZxlibJLw "PHP – Try It Online") |
| **Ruby** | **[Try it online!](https://tio.run/##PY5Bi8IwEIXv@ytmi2Cy0CHpNWZB0KsH2VvrBqWxBsJY0ogVZP96TcT1MAPz5n1vJlwOtymAhq3t7Ngj2Suslj9LDHbfKnBaKLienLfgdWfj8AHgjuDrUu60LhoqVFr4WiCW1U6BpTY5koJD711k83LOXwh6S108Mb6oElMnPmFv5HgOQOAIsojxbByTgiNm43tMvmcWK8biizjoPwgqC@4z/9lf4vDMy3/LNAdHEej/RO65jFlvVsZMvyMbWdMt5DdvqjufTZMoZSXEAw "Ruby – Try It Online")** | **[Try it online!](https://tio.run/##PY5Bi8IwEIXv/oqxCCZCh6TXmBVBrx5kb60bdjHWQBhLGrFe/OvdRNTDDMyb972ZcP27jwE07G1rhw7J3mCz/l5jsL9HBU4LBbez8xa8bm3sJwDuBL4u5UHroqFCpYWvBWJZHRRYOiZHUrDvvItsXs75C0FvqY1nxpdVYurEJ@yDnC4BCBxBFjFejGNScMRs/IzJ98xixVAsiIN@QFBZcNP8Z3eN/TMv/y3THBxFoPeJ3HMZs91tjBl/Bjawpl3KrxVvKj4bR1HKSoh/ "Ruby – Try It Online")** |
This is a port of the non-atomic recursive regex to Ruby's subroutine call syntax.
[Answer]
# [Thunno](https://github.com/Thunno/Thunno) `-`, \$ 4 \log\_{256}(96) \approx \$ 3.29 bytes
```
bdiP
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72sJKM0Ly9_abSSrlLsgqWlJWm6FkuSUjIDIEyoyIJFxkYQFgA)
or [verify all test cases](https://ato.pxeger.com/run?1=m72sJKM0Ly9_weJ0Q92lpSVpuhZLklIyAyDMBVBqsaGBAYQJAA)
Port of [Dennis's MATL answer.](https://codegolf.stackexchange.com/a/142577/114446)
## [Thunno](https://github.com/Thunno/Thunno) `DD`, \$ 5 \log\_{256}(96) \approx \$ 4.12 bytes
```
1-A^<
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72sJKM0Ly9_WbSSi4tS7IKlpSVpuhZLDXUd42wgbKjQgkXGRhAWAA)
or [verify all test cases](https://ato.pxeger.com/run?1=m72sJKM0Ly9_UXTs4nQXl6WlJWm6FksNdR3jbCDsBVBqsaGBAYQJAA)
Port of [Dennis's Jelly answer.](https://codegolf.stackexchange.com/a/142578/114446)
**Note**: a plain "power of two" answer would be 5 chars: [`b1c1=`](https://ato.pxeger.com/run?1=m72sJKM0Ly9_wYKlpSVpuhZLkwyTDW0hbKgQTAoA) (is the count of 1s in the binary representation equal to 1?)
#### Explanation
```
bdiP # Implicit input
# - flag decrements
b # Convert to a binary string
di # Get the list of digits
# This is a non-empty list of ones
# if the input is a power of two
P # Push the product of this list
# Implicit output
```
```
1-A^< # Implicit input
1- # Subtract one
A^ # Xor with input
# The highest set bit will only be conserved
# if the input is a power of two
< # Is more than input?
# Implicit output
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `g`, 4 bytes
```
K·∏£v‚ÇÇ
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyJBZyIsIiIsIkvhuKN24oKCIiwiIiwiMlxuNFxuMTZcbjEyOFxuMTBcbjEyXG4xNFxuMThcbjEiXQ==)
Can probably be golfed but it’s painful to do this on mobile.
Outputs `1` for truthy, `0` or the empty list for falsy.
```
K # divisors of input
·∏£ # without the first element
v # vectorize the following over it
‚ÇÇ # is even?
# (after which the `g` flag takes the minimum of the stack)
```
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 40 bytes
```
param($i)(($i-band(-$i))-eq$i)-and$i-ne0
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/vyCxKDFXQyVTUwNI6CYl5qVo6AJ5mrqphUBKF8gHCuelGvz//9/QyAIA "PowerShell – Try It Online")
[Answer]
# [Thunno 2](https://github.com/Thunno/Thunno2) `M`, 2 [bytes](https://github.com/Thunno/Thunno2/blob/main/docs/codepage.md)
```
⁻ḃ
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m728JKM0Ly_faGm0kq9S7IKlpSVpuhbLHjXufrijeUlxUnIxVGjBImMjCAsA)
Port of [Dennis's MATL answer](/a/142577/114446): decrement, convert to binary, take minimum.
---
A plain "power of two" answer would be **4 [bytes](https://github.com/Thunno/Thunno2/blob/main/docs/codepage.md):**
```
2BS·∏Ö
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m728JKM0Ly_faMGCpaUlaboWy4ycgh_uaF1SnJRcDBVasMjYCMICAA)
Convert to a binary list, sum equals one?
[Answer]
# [Neim](https://github.com/okx-code/Neim), 3 bytes
```
ùêÖ·õÉùê©
```
Doesn't work on TIO.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 5 bytes
```
ÆEL’¬
```
[Try it online!](https://tio.run/##y0rNyan8//9wm6vPo4aZh9b8///fBAA "Jelly – Try It Online")
[Answer]
# [Retina](https://github.com/m-ender/retina), 25 bytes
```
.+
$*
+`^(11+)\1$
$1
^11$
```
[Try it online!](https://tio.run/##K0otycxL/P9fT5tLRYtLOyFOw9BQWzPGUIVLxZArztBQ5f9/QzMA "Retina – Try It Online")
[Answer]
# [Actually](https://github.com/Mego/Seriously), 5 bytes
```
;R‚ôÇ‚ïôc
```
[Try it online!](https://tio.run/##S0wuKU3Myan8/9866NHMpkdTZyb//28BAA "Actually – Try It Online")
Explanation:
```
;R‚ôÇ‚ïôc
; duplicate n
R range(1, n+1)
‚ôÇ‚ïô powers of 2
c contains n
```
[Answer]
# [Haskell](https://www.haskell.org/), 24 bytes
```
f n=elem n$map(2^)[1..n]
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P00hzzY1JzVXIU8lN7FAwyhOM9pQTy8v9n9uYmaegq1CSj4XJ1DCV0EjpkJB106hoLQkuKTIJ09BRaE4I79coUJbW0nXTklbG8TTSFOo0NRUiDbQ0zM0MIj9DwA "Haskell – Try It Online")
[Answer]
# [Actually](https://github.com/Mego/Seriously), 4 bytes
```
yN2=
```
[Try it online!](https://tio.run/##S0wuKU3Myan8/7/Sz8j2/39DAA "Actually – Try It Online")
] |
[Question]
[
**Closed**. This question needs to be more [focused](/help/closed-questions). It is not currently accepting answers.
Closed 9 years ago.
**Locked**. This question and its answers are [locked](/help/locked-posts) because the question is off-topic but has historical significance. It is not currently accepting new answers or interactions.
Your challenge here is to draw a [trololologram](http://www.google.pt/search?q=trololologram).
You can choose any language.
The answer with more upvotes and the one that exploits more holes wins.
Rules for valid answers:
* You can't use any network resource or external file (except the source-code)
* You can't post someone else's answer
* You can't have it stored in any image format or pre-rendered (including base64 data:// uri's and any form of ascii art).
* You can't store the image in any database.
* You can't simply print/echo 'trololologram' (case insensitive)
* Explain your answers and what holes you exploited.
* The code must render the trolologram on the screen (minimum size of 90x90) and must be with a black border and white background. The rendered version can't "be invisible" or "hidden behind the screen" or similar.
* The image must show in the screen. It can't output the code to a file or anything similar (/dev/null doesn't count and virtual screens/viewports also don't count).
The main goal is to twist the rules and bend them at your own will and stil render a trololologram on screen.
Have fun!
[Answer]
For this challenge, I am posting five programs in this answer, all in Java.
## Program 1
>
> You can't simply print/echo 'trololologram' (case insensitive)
>
>
>
```
public class JustPrintIt {
public static void main(String[] args) {
System.out.println("trololologram");
}
}
```
---
## Program 2
>
> You can't [...] pre-rendered ([...] and any form of ascii art).
>
>
>
```
public class AsciiArt {
public static void main(String[] args) {
System.out.println(
" ######################## \n" +
" ## # \n" +
" # # \n" +
" # ## \n" +
" # # \n" +
" # # \n" +
" # # \n" +
" # ## \n" +
" # ##### \n" +
" # ######### \n" +
" ############ \n");
}
}
```
---
## Program 3
>
> You can't use any network resource or external file (except the source-code)
>
>
> You can't have it stored in any image format or pre-rendered (including base64 data:// uri's [...]).
>
>
> You can't store the image in any database.
>
>
> The code must render the trolologram on the screen [...].
>
>
> The image must show in the screen. It can't output the code to a file [...].
>
>
>
```
import java.awt.image.BufferedImage;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.Base64;
import javax.imageio.ImageIO;
public class DownloadAndStore {
public static void main(String[] args) throws IOException, ClassNotFoundException, SQLException {
String url = "http://img171.imageshack.us/img171/8555/trolologramw400.jpg";
BufferedImage im = ImageIO.read(new URL(url));
ImageIO.write(im, "png", new File("trolologram.png"));
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ImageIO.write(im, "png", baos);
String d = "data://" + new String(Base64.getEncoder().encode(baos.toByteArray()));
Class.forName("com.mysql.jdbc.Driver");
try (Connection con = DriverManager.getConnection("jdbc:mysql://localhost:3306", "root", "root")) {
try (PreparedStatement ps = con.prepareStatement("CREATE DATABASE troll")) {
ps.executeUpdate();
} catch (SQLException e) {
if (!e.getMessage().contains("database exists")) throw e;
}
try (PreparedStatement ps = con.prepareStatement("CREATE TABLE troll.image (imagedata text not null)")) {
ps.executeUpdate();
} catch (SQLException e) {
if (!e.getMessage().contains("already exists")) throw e;
}
try (PreparedStatement ps = con.prepareStatement("INSERT INTO troll.image (imagedata) VALUES (?)")) {
ps.setString(1, d);
ps.executeUpdate();
}
}
}
}
```
---
## Program 4
>
> Your challenge here is to draw a trololologram.
>
>
> You can't use any network resource or external file (except the source-code)
>
>
> You can't post someone else's answer
>
>
> You can't have it stored in any image format or pre-rendered [...].
>
>
> [...] (minimum size of 90x90) and must be with a black border and white background. [...].
>
>
>
```
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.net.URL;
import javax.imageio.ImageIO;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.SwingUtilities;
public class ShowTheAnswerOfSomebodyElse {
public static void main(String[] args) throws IOException {
// See this: http://codegolf.stackexchange.com/a/20085/3755
String url = "http://placehold.it/99/png&text=Hello+world!";
BufferedImage im = ImageIO.read(new URL(url));
BufferedImage im2 = new BufferedImage(89, 89, BufferedImage.TYPE_INT_ARGB);
im2.createGraphics().drawImage(im, 0, 0, null);
SwingUtilities.invokeLater(() -> createAndShowGUI(im2));
}
private static void createAndShowGUI(BufferedImage im) {
JFrame frame = new JFrame("");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
JComponent panel = new JComponent() {
@Override
public Dimension getPreferredSize() {
return new Dimension(im.getWidth(), im.getHeight());
}
@Override
public Dimension getMinimumSize() {
return new Dimension(im.getWidth(), im.getHeight());
}
@Override
public Dimension getMaximumSize() {
return new Dimension(im.getWidth(), im.getHeight());
}
@Override
public void paintComponent(Graphics g) {
g.drawImage(im, 0, 0, null);
}
};
frame.add(panel);
frame.pack();
frame.setVisible(true);
}
}
```
---
## Program 5
>
> You can't use any network resource or external file (except the source-code)
>
>
> You can't have it stored in any image format or pre-rendered [...].
>
>
> The code must render the trolologram on the screen [...] and must be with a black border and white background. The rendered version can't "be invisible" or [...].
>
>
> The image must show in the screen. [...].
>
>
>
```
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.net.URL;
import javax.imageio.ImageIO;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.SwingUtilities;
public class ShowTheTrolologramOnScreenButNot {
public static void main(String[] args) throws IOException {
String url = "http://img171.imageshack.us/img171/8555/trolologramw400.jpg";
BufferedImage im = ImageIO.read(new URL(url));
for (int i = 0; i < im.getHeight(); i++) {
for (int j = 0; j < im.getWidth(); j++) {
int rgb = im.getRGB(j, i);
int r = 255 - (rgb >> 16 & 0xff);
int g = 255 - (rgb >> 8 & 0xff);
int b = 255 - rgb & 0xff;
im.setRGB(j, i, 0xFF000000 + (r << 16) + (g << 8) + b);
}
}
SwingUtilities.invokeLater(() -> createAndShowGUI(im));
}
private static void createAndShowGUI(BufferedImage im) {
JFrame frame = new JFrame("");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
JComponent panel = new JComponent() {
@Override
public Dimension getPreferredSize() {
return new Dimension(im.getWidth(), im.getHeight());
}
@Override
public Dimension getMinimumSize() {
return new Dimension(im.getWidth(), im.getHeight());
}
@Override
public Dimension getMaximumSize() {
return new Dimension(im.getWidth(), im.getHeight());
}
@Override
public void paintComponent(Graphics g) {
g.drawImage(im, 0, 0, null);
}
};
frame.add(panel);
panel.setVisible(false); // :)
frame.pack();
frame.setVisible(true);
}
}
```
---
## And finally...
>
> Explain your answers and what holes you exploited.
>
>
>
So here it is:
>
> The answer with more upvotes and the one that exploits more holes wins.
>
>
>
There is hole in this: you did not said that it must be a valid answer to be accepted!
[Answer]
# Java 8
Here it is:
>
> You can't use any network resource or external file (except the source-code)
>
>
>
I am reading the source-code.
>
> You can't post someone else's answer
>
>
>
What about someone else's question?
>
> You can't have it stored in any image format or pre-rendered (including base64 data:// uri's and any form of ascii art).
>
>
>
It is indeed not an image format. It is not ascii-art either, since all the characters are the same. It is not pre-rendered either, its source is just english text.
If you insists, this is ascii-art:
```
/-------\
| |
| O O |
| |
| ----- |
\-------/
```
This is not ascii-art:
```
XXXXXXXXX
XXXXXXXXX
XXXXXXXXX
XXXXXXXXX
XXXXXXXXX
XXXXXXXXX
```
>
> You can't store the image in any database.
>
>
>
It does not, but it saves an SQL's INSERT statement into a file.
>
> You can't simply print/echo 'trololologram' (case insensitive)
>
>
>
Yes, I do not do simply that.
>
> Explain your answers and what holes you exploited.
>
>
>
I am already doing that.
>
> The code must render the trolologram on the screen (minimum size of 90x90) and must be with a black border and white background. The rendered version can't "be invisible" or "hidden behind the screen" or similar.
>
>
>
Indeed it has a minimum size of 90x90.
>
> The image must show in the screen. It can't output the code to a file or anything similar (/dev/null doesn't count and virtual screens/viewports also don't count).
>
>
>
Indeed, it does not outputs code to a file, it outputs something else!
---
Here, a screenshot:
Here, the code:
```
import java.awt.Dimension;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.SwingConstants;
import javax.swing.SwingUtilities;
import javax.swing.UIManager;
/*
THIS IMAGE IS NOT PRE-RENDERED, I SWEAR THAT!#THIS image is not pre-rendered, i swEAR THAT!#THis IMAGE IS NOT PRE-RENDERED, I SWeAR THAT!#THiS IMAGE IS NOT PRE-RENDERED, I SWEaR THAT!#ThIS IMAGE IS NOT PRE-RENDERED, I SWEAr tHAT!#ThIS IMAGE IS NOT PRE-RENDERED, I SWEAR ThAT!#ThIS IMAGE IS NOT PRE-RENDERED, I SWEAR ThAT!#THiS IMAGE IS NOT PRE-RENDERED, I SWEAR tHAT!#THiS IMAGE IS NOT PRE-RENDERED, I SWEar THAT!#THiS IMAGE IS NOT PRE-RENDEREd, i sweAR THAT!#THiS IMAGE IS NOT Pre-rendereD, I SWEAR THAT!#THIs image is not pRE-RENDERED, I SWEAR THAT!#THIS IMAGE IS NOT PRE-RENDERED, I SWEAR THAT!
*/
public class Trolologram {
public static void main(String[] args) throws IOException {
String s = readContents(new File("Trolologram.java"))
.replaceAll("\n|\r", "#")
.replaceAll("##+", "#")
.replaceAll(".*\\Q/" + "*\\E", "")
.replaceAll("\\Q*" + "/\\E.*", "");
String x = createImage(s.substring(1, s.length() - 2));
System.out.println("'trololologram' (case insensitive)");
writeContents("'trololologram' (case insensitive)##" + s, new File("database.output"));
SwingUtilities.invokeLater(() -> {
UIManager.put("swing.boldMetal", Boolean.FALSE);
createAndShowGUI(x);
});
}
private static String readContents(File input) throws IOException {
StringBuilder sb = new StringBuilder((int) input.length());
try (FileInputStream fis = new FileInputStream(input)) {
int a;
while ((a = fis.read()) != -1) {
sb.append((char) a);
}
}
return sb.toString();
}
private static void writeContents(String toWrite, File output) throws IOException {
try (FileOutputStream fos = new FileOutputStream(output)) {
for (char c : toWrite.toCharArray()) {
fos.write(c == '#' ? '\n' : c);
}
fos.write('\n');
fos.write('\n');
for (char c : toWrite.substring(37).toCharArray()) {
if (" ,!-".contains("" + c)) continue;
fos.write(c == '#' ? '\n' : c <= 'Z' ? ' ' : '#');
}
fos.write('\n');
fos.write('\n');
fos.write(("INSERT INTO troll (imagedata) VALUES ('" + toWrite.substring(37) + "')").getBytes());
}
}
private static String createImage(String s) {
String[] lines = s.split("#");
StringBuilder html = new StringBuilder(10000);
html.append("<html>");
boolean first = true;
for (String line : lines) {
if (first) {
first = false;
} else {
html.append("<br>");
}
html.append("<code>");
for (char c : line.toCharArray()) {
if (" !,-".contains("" + c)) continue;
String color = c <= 'Z' ? "white" : "black";
html.append("<font color=" + color + ">X</font>");
}
html.append("</code>");
}
return html.toString();
}
private static JLabel label(boolean a, String text) {
JLabel theLabel = new JLabel(text) {
@Override
public Dimension getPreferredSize() {
return new Dimension(a ? 350 : 500, 400);
}
@Override
public Dimension getMinimumSize() {
return new Dimension(a ? 350 : 500, 400);
}
@Override
public Dimension getMaximumSize() {
return new Dimension(a ? 350 : 500, 400);
}
};
theLabel.setVerticalAlignment(SwingConstants.CENTER);
theLabel.setHorizontalAlignment(SwingConstants.CENTER);
return theLabel;
}
private static String Q = "<html>Your challenge here is to draw a <font color='#4e82c2'>trololologram</font>." +
"<br>" +
"You can choose any language." +
"<br>" +
"The answer with more upvotes and the one that exploits more holes wins." +
"<br>" +
"Rules for valid answers:" +
"<ul>" +
"<br><li>You can't use any network resource or external file (except the source-code)" +
"<br><li>You can't post someone else's answer" +
"<br><li>You can't have it stored in any image format or pre-rendered (including base64 data:// uri's and any form of ascii art)." +
"<br><li>You can't store the image in any database." +
"<br><li>You can't simply print/echo 'trololologram' (case insensitive)" +
"<br><li>Explain your answers and what holes you exploited." +
"<br><li>The code must render the trolologram on the screen (minimum size of 90x90) and must be with a black border and white background. The rendered version can't \"be invisible\" or \"hidden behind the screen\" or similar." +
"<br><li>The image must show in the screen. It can't output the code to a file or anything similar (/dev/null doesn't count and virtual screens/viewports also don't count)." +
"</ul>" +
"<br>" +
"The main goal is to twist the rules and bend them at your own will and stil render a trololologram on screen." +
"<br>" +
"Have fun!";
private static void createAndShowGUI(String x) {
JFrame frame = new JFrame("'trololologram' (case insensitive)");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
JPanel panel = new JPanel();
panel.setLayout(new BoxLayout(panel, BoxLayout.LINE_AXIS));
panel.add(label(true, x));
panel.add(Box.createRigidArea(new Dimension(10, 0)));
panel.add(label(false, Q));
frame.add(panel);
frame.pack();
frame.setVisible(true);
}
}
```
[Answer]
# HTML/JavaScript (with a vengeance)
Since the humorous trollesque approach did not meet with an unadulterated success, here is my hackish JavaScript attempt, complete with its state-of-the-art HTML wrapper:
```
<script>function _(_,l,I,j){_-=i%$/5;l-=i*(j||.4)/$;return _*_+l*l<I*I/4}l='<pre>';$=90;for(
i=0;i<4e3;i++)l+=i%$?' %'[!(_(6,9,2,.8)|_(13,12,3,1)|_(7,48,5,1.4)|_(10,33,2,1))&(_(5,7,8)|_(
15,7,6)|_(-20,9,74)&_(38,9,72)&_(9,20,40)&_(-8,-10,64))]:'\n';document.write(l)</script>
```
*(linefeeds added for readability)*
Should produce something like this:
Skeptical people can see a live example [here](http://petiteleve.free.fr/SO/trolologram1.html).
EDIT: let's review the rules point per point
>
> You can't use any network resource or external file (except the source-code)
>
>
>
No problem there. You can run a script from within an HTML page directly from your hard disk.
>
> You can't post someone else's answer
>
>
>
Check.
>
> You can't have it stored in any image format or pre-rendered (including base64 data:// uri's and any form of ascii art).
>
>
>
Check.
>
> You can't store the image in any database.
>
>
>
Check, provided the function parameters are not considered part of a database.
>
> You can't simply print/echo 'trololologram' (case insensitive)
>
>
>
I was tempted to use the characters in "trololologram" instead of "%" as a filler, but that would have had an intolerable impact on the size of the program.
>
> The code must render the trolologram on the screen (minimum size of 90x90) and must be with a black border and white background.
>
>
>
Check (you did not specify the interior color).
>
> The rendered version can't "be invisible" or "hidden behind the screen" or similar.
>
>
>
Check.
>
> The image must show in the screen. It can't output the code to a file or anything similar (/dev/null doesn't count and virtual screens/viewports also don't count).
>
>
>
As long as your browser window is not obscured, it's clearly showing the image on the screen. It's your genuine display, no cryptic device or virtual screen or viewport.
>
> Explain your answers and what holes you exploited.
>
>
>
An HTML page, once rendered, *is* (among other things) an image displayed on the screen.
You can capture it, store it to disk, photoshop it, email it to relatives and friends, print it on genuines bits of dead trees and light a fire with it for all I care, but it's a friggin *image*.
About the ressemblance with the original trololologram, I do not claim to be an artist. Consider this code as a proof of concept. If someone wants to spend the hour(s) needed to tweak and add more elements to get closer to the original, he/she is welcome to do so.
[Answer]
# Autoit 3 Script
```
$trol=ASCIIGenerate(4,1,1,0)&ASCIIGenerate(24,0,0,1)&ASCIIGenerate(2,1,1,0)&ASCIIGenerate(2,0,0,0)&ASCIIGenerate(24,1,0,0)&ASCIIGenerate(1,0,0,1)&ASCIIGenerate(2,1,1,0)&ASCIIGenerate(1,0,0,0)&ASCIIGenerate(26,1,0,0)&ASCIIGenerate(1,0,0,1)&ASCIIGenerate(1,1,1,0)&ASCIIGenerate(1,0,0,0)&ASCIIGenerate(28,1,0,0)&ASCIIGenerate(2,0,0,1)&ASCIIGenerate(1,1,1,0)&ASCIIGenerate(1,0,0,0)&ASCIIGenerate(30,1,0,0)&ASCIIGenerate(1,0,0,1)&ASCIIGenerate(1,1,1,0)&ASCIIGenerate(1,0,0,0)&ASCIIGenerate(30,1,0,0)&ASCIIGenerate(1,0,0,1)&ASCIIGenerate(2,1,1,0)&ASCIIGenerate(1,0,0,0)&ASCIIGenerate(28,1,0,0)&ASCIIGenerate(1,0,0,1)&ASCIIGenerate(2,1,1,0)&ASCIIGenerate(1,0,0,0)&ASCIIGenerate(26,1,0,0)&ASCIIGenerate(2,0,0,1)&ASCIIGenerate(2,1,1,0)&ASCIIGenerate(1,0,0,0)&ASCIIGenerate(21,1,0,0)&ASCIIGenerate(5,0,0,1)&ASCIIGenerate(2,1,1,0)&ASCIIGenerate(1,0,0,0)&ASCIIGenerate(12,1,0,0)&ASCIIGenerate(9,0,0,1)&ASCIIGenerate(3,1,1,0)&ASCIIGenerate(12,0,0,1)
RunWait("cmd /C @echo off&color F0&"&$trol&"pause > nul")
Func ASCIIGenerate($num,$char,$echo,$and)
Local $i=0
Local $str=""
If $echo=1 Then
$str&="echo "
EndIf
Do
Switch $char
Case 0
$str&="#"
Case 1
$str&="Â "
EndSwitch
$i+=1
Until $i=$num
If $and=1 Then
$str&="&"
EndIf
Return $str
EndFunc
```
Output:
Holes exploited:
>
> You can't have it stored in any image format or pre-rendered (including base64 data:// uri's and any form of ascii art).
>
>
>
The ASCII art is generated by the script on the fly. The script itself only has info on which and how many characters it must draw onscreen and when start a new line.
>
> You can't store the image in any database.
> The image must show in the screen. It can't output the code to a file or anything similar (/dev/null doesn't count and virtual screens/viewports also don't count).
>
>
>
The script doesn't create nor contain any files. When generated, the ASCII art is loaded onto the computer's RAM and then shown via CMD commands (without using any batch files, only cmd /c ).
>
> The code must render the trolologram on the screen (minimum size of 90x90) and must be with a black border and white background. The rendered version can't "be invisible" or "hidden behind the screen" or similar.
>
>
>
The image displayed onscreen is way bigger than 90x90 and it's black on a white background.
[Answer]
# HTML/CSS
```
<p style='font-size:100px'}>😆
```
# 😆
>
> You can't have it stored in any image format or pre-rendered (including base64 data:// uri's and any form of ascii art).
>
>
>
Well it's not me that does the rendering, it's the browser.
And there is no ASCII here, only unicode :p.
[Answer]
## HTML
>
> Even ○ would be a better answer. – [Ismael Miguel](https://codegolf.stackexchange.com/users/14732/ismael-miguel) Feb 23 at 0:12
>
>
>
Well here it is:
```
â—‹
```
(with the browser zoomed in until it gets 90x90)
] |
[Question]
[
**This question already has answers here**:
[Output your Score!](/questions/160646/output-your-score)
(188 answers)
Closed 4 years ago.
# Introduction
A quine is a program that takes no input and produces a copy of its own source code as output. Writing a quine is a standard test of a programming language. Most quines operate using strings of characters: that is what the source code is made of, after all! However, this quine is slightly different.
# Challenge
Your challenge is to write a program that takes no input and produces the number of bytes in the program as output.
* By "takes no input", I mean does not change based on input. Your program can still take command line arguments, or even arguments from stdin, but it cannot do anything with them. It must either discard or ignore them. Basically, your program should produce the same output no matter what input is given.
* Your program must output the number of bytes in it. If it is a function, it can output through its return value. If, and only if your language has no stdout, you may store output in a variable. The input can be printed as a string or an integer; the user cannot tell the difference between the output of `print('5')` or `print(5)`! Note that I said byte count, not character count. If your program uses Unicode characters that take up more than 1 byte (like some Jelly or APL programs), the output must reflect that.
# Rules
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so shortest answer in bytes wins! Edit: Actually, since there is a 1 byte answer, let's do top 3 shortest.
Edit: this question is not the same as [Output your Score](https://codegolf.stackexchange.com/questions/160646/output-your-score). For one, this one does not disallow cheating quines. Also, I do not require a trailing " bytes" in output.
[Answer]
# Most languages, 0 bytes
[Try it online!](https://tio.run/##K0gtyjH7DwQA "Perl 6 – Try It Online")
Outputs via exit code, which is `0` for almost any language where an empty program is valid.
[Answer]
# [Poetic](https://mcaweb.matc.edu/winslojr/vicom128/final/tio/index.html), ~~87~~ 86 bytes
*-1 byte due to a slightly better representation of the character "8".*
```
hey-o
i guess i got a number i can write
an apple a day keeps doctors away, we suppose
```
[Try it online!](https://mcaweb.matc.edu/winslojr/vicom128/final/tio/index.html?DYnBDYAwDMT@THEDwFCBngABTdS0qjp9ycu2fHFsutw4G90R1ApBbt/OEnlIRi935RIiZi/jJhl4SHMkPaoWh3QZKzrhzUydc@6Sfg)
Poetic is an esolang I made in 2018 for a class project. It's basically brainfuck with word-lengths instead of symbols.
I couldn't resist making the word-lengths spell out a popular phrase, hehe. üçé ü뮂Äç‚öïÔ∏è
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 1 byte
```
1
```
[Try it online!](https://tio.run/##y0rNyan8/9/w/38A "Jelly – Try It Online")
This probably works in a lot of other languages as well. Note that the output does *not* have a trailing newline
[Answer]
# [Python 2](https://docs.python.org/2/), 7 bytes
```
print 7
```
[Try it online!](https://tio.run/##K6gsycjPM/r/v6AoM69Ewfz/fwA "Python 2 – Try It Online")
[Answer]
# [Keg](https://github.com/JonoCode9374/Keg), 2 bytes
```
2#
```
[Try it online!](https://tio.run/##y05N///fSPn/fwA "Keg – Try It Online")
Not a duplicate, and this should hopefully clinch me 3rd place :)
[Answer]
# [Perl 5](https://www.perl.org/) `-p`, 4 bytes
```
$_=4
```
[Try it online!](https://tio.run/##K0gtyjH9/18l3tbk//@s7Bwg@pdfUJKZn1f8X9fXVM/A0OC/bgEA "Perl 5 – Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/), 3 bytes
Probably one of the only times Ruby can beat Perl in bytes.
```
p 3
```
[Try it online!](https://tio.run/##KypNqvz/v0DB@P9/AA "Ruby – Try It Online")
[Answer]
# JavaScript, 4 bytes
Boring!
```
_=>4
```
[Try it Online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@z/e1s7kf3J@XnF@TqpeTn66RpqGpuZ/AA)
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 20 bytes
```
-[>+<-----]>-.--.kek
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fN9pO20YXBGLtdPV0dfWyU4GiAA "brainfuck – Try It Online")
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 1 byte
```
^
```
[Try it online!](https://tio.run/##K0otycxL/P8/7v9/AA "Retina 0.8.2 – Try It Online") In Retina, the empty program outputs 1 more than the length of its input, which is bad here, since we don't want the output to depend on the input. Fortunately, either `^` or `$` help here, as they force the output to be `1`, which is conveniently also their length.
[Answer]
# [HQ9+](https://esolangs.org/wiki/HQ9+), 1 byte
```
+
```
This language does not allow you to write a program that prints only one number. Therefore, I save the number of bytes in a special counter.
[HQ9+ online interpreter](https://almnet.de/esolang/hq9plus.php)
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf), 1 byte
```
‚ïß
```
[Try it online!](https://tio.run/##y00syUjPz0n7///R1OX//wMA "MathGolf – Try It Online")
## Explanation
```
‚ïß On the empty stack, pop a,b, push a.contains(b)
0 definitely contains 0, pushing a 1.
Implicit output
```
# [MathGolf](https://github.com/maxbergmark/mathgolf), 1 byte
```
)
```
[Try it online!](https://tio.run/##y00syUjPz0n7///R1OWa//8DAA "MathGolf – Try It Online")
## Explanation
```
) Increment this 0 value on the stack, returning a 1.
```
# [MathGolf](https://github.com/maxbergmark/mathgolf), 1 byte
```
=
```
[Try it online!](https://tio.run/##y00syUjPz0n7/9/2/38A "MathGolf – Try It Online")
## Explanation
```
= Check equality of 0 and 0, returns 1.
```
[Answer]
# [Metatape](https://github.com/HactarCE/Metatape), 22 bytes
```
@a{ooxooeooxoeo} !a !a
```
The space characters are not syntactically necessary, but they take up less space than it would to output `21` or `20`.
`@a{...}` defines a subroutine named `a`, and `!a` executes that subroutine.
Output is bitwise (highest bit first). While the actual language is more complicated, for the sake of this program:
* `x` makes subsequent `o`s output `1`.
* `e` makes subsequent `o`s output `0`.
[Answer]
# [R](https://www.r-project.org/), 6 bytes
```
cat(6)
```
[Try it online!](https://tio.run/##K/r/PzmxRMNM8/9/AA "R – Try It Online")
(Note that Jo King's [0 byte answer](https://codegolf.stackexchange.com/a/195189/86301) is also valid in R.)
[Answer]
# [Bash](https://www.gnu.org/software/bash/), 6 bytes
```
echo 6
```
[Try it online!](https://tio.run/##S0oszvj/PzU5I1/B7P9/AA "Bash – Try It Online")
[Answer]
# [Rust](https://www.rust-lang.org/), 3 bytes
```
||3
```
[Try it online!](https://tio.run/##KyotLvmflqeQm5iZp6GpUM2lAAQ5qSUKaQq2/2tqjP9bg0UKijLzSnLyFDWUqmuVdBTSNDQ1rblq/wMA "Rust – Try It Online")
[Answer]
# [PMD 85](https://en.wikipedia.org/wiki/PMD_85) BASIC, 0 bytes
Without any lines of code, `RUN` will respond with
>
> OK
>
>
>
i.e. zero kilobytes.
(yes, it's cheating)
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-F0`](https://codegolf.meta.stackexchange.com/a/14339/), 0 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LUYw&input=NA)
This can be my first 0 bytes answer!
Using -F"0" flag => outputs 0 if the programme returns a falsey value
[Answer]
# [Haskell](https://www.haskell.org/), 5 bytes
```
f a=5
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P00h0db0f25iZp5tQWlJcEmRT55KcUZ@uUqagpnlfwA "Haskell – Try It Online")
[Answer]
# [Turing Machine Code](http://morphett.info/turing/turing.html), 9 bytes
```
0 _ 9 * 1
```
[Try it online!](http://morphett.info/turing/turing.html?e05158677198c61249c8038480d3ead6)
] |
[Question]
[
From [here](https://codegolf.meta.stackexchange.com/questions/2140/sandbox-for-proposed-challenges/22219#22219). Every new game is the first day of the month, 12:00 PM UTC.
The goal is to create the Stack Overflow logo using ASCII characters.
It looks like this.
[](https://i.stack.imgur.com/Ylw9X.png)
The exact output should look like this:
```
\\
\\
\= \\
\= \\
\= \\
\== \\
¯¯¯ \==
¯¯¯¯¯
_______ ¯¯¯¯
____
| ____________ |
| |
¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
```
It must be worth mentioning that it must represent the same form of the actual logo, wherein the lines' (which I would call sticks) layering should be aligned as the way of the one from the picture. You can use either spaces or newlines to add another line for drawing the logo.
Remember, 5 sticks facing different angles and 1 tray holding them.
Can you draw it with the least bytes possible?
[Answer]
# [Python 3](http://docs.python.org/3), ~~121~~ ~~120~~ 108 bytes
Inspired by [@Enzo's answer](https://codegolf.stackexchange.com/a/224863/91685), this works very similarly, except it encodes using a bytestring instead of an integer in base 36. Thanks also to @xnor for shaving 12 bytes off.
Each character in the encoding is equal to `chr(' |\\=_¯\n'.index(c) + 7*n + 28)` where a symbol `c` should be repeated `n` times; the `+ 28` is just so it's in the printable ASCII range. The last repetition is encoded as `¯` 8 times twice, instead of `¯` 16 times, for the same reason.
```
for x in b'T,)b,)?%&8,)M%&8,)[%&1,)i%-*,)86M%-)MD)1Q*=)b<)$#t#$)$~$)YY':print(end=' |\=_¯\n'[x%7]*(x//7-4))
```
[Try it online!](https://tio.run/##K6gsycjPM/7/Py2/SKFCITNPIUk9REczSUfTXlXNQkfTF0xGq6oZ6mhmqupq6WhamPmq6mr6umgaBmrZaibZaKoolyiraKrUqWhGRqpbFRRl5pVopOal2Kor1MTYxh9aH5OnHl2hah6rpVGhr2@ua6Kp@f8/AA)
[Answer]
# JavaScript (ES6), 154 bytes
```
_=>` 8#10#5\\= 4#7\\= 4#9\\= 3#11\\== #4¯3 7\\==
7¯5
3_7 ¯4
10_4
| _12 |
| 14|
¯16`.split`#`.join`\\2
`.replace(/.(\d+)/g,(s,n)=>s[0].repeat(n))
```
[Try it online!](https://tio.run/##JckxDoMgGEDhnVP8CQumFkWxtgNepDRgFI3GgBHTyTtxBy9mNZ2@5L2x/ta@WYZ5vVvXmqMThxKVhidmKS6kFMBx@ed1kWPGTgUA5nvI4XoCQbmHAkGuSoA9cAQsVRxtoFgG2ynjG9oDe2jq52lYNdZ0dIPVUmYINF3MPNWNIQklsr1FSR8TH9tIVP6dfq5r6pXYKDoaZ72bDJ1cTzpyhh8 "JavaScript (Node.js) – Try It Online")
[Answer]
# [Splinter](https://esolangs.org/wiki/Splinter), ~~160~~ 153 bytes
```
A{\
}B{\ }C{BB}D{CC}E{DD}EF{\\}G{FFA}GCEGBDH{FI{\=}I}HDGR{BC}RDHDGEBHRGERHICGDK{\-}L{KK}KLRDHIARDM{LL}MKARN{\_}P{NNNN}NNNPCMAECPAQ{\|}QBPPPBQAQCDEQAMMMM
```
[Try it online!](https://tio.run/##tVVrr5pAEP3Or5jQL9oWIya9ac21CS8fUW@Qr2IaKnjdVMEsq96b7f52Oygqokgft5OYuOwwc87xzLh6ZfMobOzewTTySfjchDWbKZ@lFY2eoQVUluWdxl1J6NwFYXBdFyY3DGFx0xRWm7uu6PB2WxMdw@roZpe3e9xtiZ7omh2H64ZwTPxm6V2nYzndntEx@9xVxID3@6I/wMue5phDPhiIYV9znrj7Tdj8CUPgxzaGmmXY2oi7P8VIt21bH2kjw7RG2hBjh@AkiSxXEWUQv8YSxjJYIuyxLE/gPTQeJGk7J4sAFkFYSShV4SvUmxJgkBlE1N8/HdcneNGCh0/ghf7l48cWfEnfSGKD1evS6Ujw2DidfDypp1OIpwTgKXd2AUM9F01v9z3VCbTwPS5fXidxoOKfKeQDaxB4PHe5nXXEFsKHQ0sykQoTj7DIAZbrysVFj4IQLKzez/ptoEWA7@UGizgor7iiJGQgW5RG9COsw6XHpnOcAPhOvemPgMVAQmDzYN@SesuaXFoSPVgLXgirVKVibDlFeZmgGZsSUEC9bdXjVc6uRZE41S/9mf5GyJN6W4KbZc3Ag3i1wIyAoqA@mXosov9JS1Gi5YG1UsD6Pts3tEsJteIRwuU2vlhOCvpgkkzGuKmo10OxudhHl5KpxZK9AdUbFLHxJmmZc2f6R1NALR14tXkmd/0zpSUOTkgzz0TrNzbX/VWcgI@Zj@atbSlhQSUVrHoXQ1YzLwR8e4XuJ2HM6HrKSBRmJmI691DKZCRYlGbmRLwhYJZmo4hmdp3822DmEFx1EoWd/sgxV22yymYpJx7Y/QI "Python 2 – Try It Online")
Note: Due to a bug in the interpreter, only 1-byte characters can be printed. If the interpreter worked properly, I could just replace the hyphen with an overline, printing the correct result.
[Answer]
# [Python 3](https://docs.python.org/3/), 205 186 180 172 169 bytes
*-8 bytes* thanks to @kaya3
*-4 bytes* thanks to @Makonede
```
for i in range(58):m=int('7IPPQA9UU6JJAOWWU17I77P5ZEVJ0ASTQRZNTQCX7GD0BJ6Z2F6P6PBFO9DU4F4GFYC7ST87K89MCKVO9S08KDRI2O',36)>>i*8&255;print(end=' \\=¯_|\n'[m&7]*(m>>3&31))
```
[Try it online!](https://tio.run/##Fc1ZCoJAAADQq8yXG324zoyFgkuKSjnuZUYEWfnhKOJP0J26Qxczehd442t@DlRZlvswgQ50FExX@mg5DfPr3ujozLEoICSx9KKAYWjFVVVIKECIaPW2DEUry5O03ueJc0C@K9ohrGUPEkhsL9bdQvVU3zs6KMsxirC@c6Iy1jMRR24ayDG7UiBvmp2AGVnTNuP0/1p6M1jQNMb3c3k3lD31DDoLXG@aCqNIPL8sPw "Python 3 – Try It Online")
Encodes the output into a integer in groups of 8 bits for each character. The first 5 bits represents the length of this character in the original output and the last 3 bits the character index in `s`.
Ungolfed:
```
g = int('7IPPQA9UU6JJAOWWU17I77P5ZEVJ0ASTQRZNTQCX7GD0BJ6Z2F6P6PBFO9DU4F4GFYC7ST87K89MCKVO9S08KDRI2O', 36)
s = ' \\=¯_|\n' # Unique characters from the expected output
for i in range(58):
m = g >> i*8 & 255 # Gets the i-th group of 8 bits from the encoded integer
i = m & 7 # The last 3 bits: index of s
n = m >> 3 & 31 # The first 5 bits: length of this character
print(s[i] * n, end='') # Prints it
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~73~~ 70 bytes
```
Ｆ³«Ｆ²¶\\←»↙Ｆ⁵«←…=⊕‹ι²↖¹»Ｍ⁴↓Ｆ354⁺¶×¯Ｉι↙↓↓²←ׯ¹⁶↗↑²↘→Ｇ→¹²_Ｆ47←⁺¶×_Ｉι
```
[Try it online!](https://tio.run/##ZU9BasMwEDzHrxA6yaAeYjstJPTkXAIuhFDfAsE4SiyQJWOrLqHkTf1DP6bIki01eE87w87sTFkVbSkKptRFtADFIfgJFmaNQrBvKZcIHvlRDww3weJD9AStM3KRGt0DC7fim4@UUa6MiRWbWwzSW8lIWokGwXeIwY6XLakJl@SMMtJ1iGIQhXo2Tpc3Vrn0jxIMzK/pD4xXCZxS7tlXN0TV7p@0Jnr/@9V7WnQSUWs9S@sJDca/AxrCOMLG@O@5fPVueXOg10r687yxau89HVjGnQt2uwo@Eto0wgCeoOuWvLlqY4R5w9NzQaXUS88e "Charcoal – Try It Online") Link is to verbose version of code. Note that there are only ~~69~~ 66 characters but I think `¯` actually requires three bytes to encode since it's not in Charcoal's code page. Output includes leading blank line. Explanation:
```
Ｆ³«Ｆ²¶\\←»
```
Print the top right stick of `\\`s.
```
↙Ｆ⁵«←…=⊕‹ι²↖¹»
```
Print the stick of `\=`s.
```
Ｍ⁴↓Ｆ354⁺¶×¯Ｉι
```
Print the stick of `¯`s.
```
↙↓↓²←ׯ¹⁶↗↑²
```
Print the box.
```
↘→Ｇ→¹²_
```
Print the horizontal stick of `_`s.
```
Ｆ47←⁺¶×_Ｉι
```
Print the other stick of `_`s.
[Answer]
# Brainfuck ~~483~~ ~~479~~ 472 bytes
## -4 bytes and fix the code thanks to Makonede
Yes... brainfuck, the best language to do ascii art :)
```
+[->---[-<]>-]><<++++[>++++++++<-]>>>>>>+[-[<+>>]<-]<-->++++++++++>>+[<+>---]<++++>>-[<++>-----]<------->>--[<+>--]<---[<]>........>..>>.[<]>..........>..>>.[<]>.....>.>.<<....>..>>.[<]>.......>.>.<<....>..>>.[<]>.........>.>.<<...>..>>.[<]>...........>.>..<<..>..>>.[<]>....>>>>...<<<<.......>.>..>.[<]>.......>>>>.....<.[<]>...>>>>>.......<<<<<..>>>>....<.[<]>..........>>>>>....<<.>>>.[<]>.[>]<<............[<]>.[>]<.<<<.>>>.[<]>..............[>]<.<<<.>................
```
[Try it by yourself](https://tio.run/##fZBLCsMwDEQPJOQTDLqI8KItFEqhi0LP7@qT@JOGTjbOvGc5zvV9ebzun9uzNVIWZlZGFa4CkEWFtsC6iHkKEqnWgLkLRM6M2JCKfHczCg43Yi2nFpXacWWLLUTK3Px0Yg9wKv9BEzw7I2jglfp1i4Mcu4vrqemYtbfSq9yKIeF4uQ7g66RqvxbTx43Wxw1vycDlkNa@)
"Beautiful" version:
```
+[->---[-<]>-]> Create \
<<++++[>++++++++<-]>>> Create space
>>>+[-[<+>>]<-]<-- Create =
>++++++++++ Create line jump
>>+[<+>---]<++++> Create weird minus sign
>-[<++>-----]<------- Create _
>>--[<+>--]<--- Create |
[<]> Return to the start and draw
........>..>>.[<]>
..........>..>>.[<]>
.....>.>.<<....>..>>.[<]>
.......>.>.<<....>..>>.[<]>
.........>.>.<<...>..>>.[<]>
...........>.>..<<..>..>>.[<]>
....>>>>...<<<<.......>.>..>.[<]>
.......>>>>.....<.[<]>
...>>>>>.......<<<<<..>>>>....<.[<]>
..........>>>>>....<<.
>>>.[<]>.[>]<<............[<]>.[>]<.<<<.
>>>.[<]>..............[>]<.<<<.
>................
```
[Answer]
# [V (vim)](https://github.com/DJMcMayhem/V), ~~85, 82~~, 81 bytes
```
i¸ \\3ñ2Ù2>jj>ñ2G6|4ñjR\= ñr=jS´ ³¯· \==
· µ¯
³ ·_ ´¯
± ´_
| ±²_ |
|±´ |ÙÒ¯
```
[Try it online!](https://tio.run/##HcchDsJAEIVhvwfA1LwLYArBbS0e7CarWYmomlPgeopm6JKi3xxsmKD@75/dH/yilOFkOtoyTq1NoetFzqbtVjJMn7nd2cHtwJU7Ss4pwk9s4gbuFWD/nwZqElD5rpAkgQ4ZbLEXV3c/zj8 "V (vim) – Try It Online")
Hexdump:
```
00000000: 69b8 205c 5c1b 33f1 32d9 323e 6a6a 3ef1 i. \\.3.2.2>jj>.
00000010: 3247 367c 34f1 6a52 5c3d 20f1 723d 6a53 2G6|4.jR\= .r=jS
00000020: b420 b316 afb7 205c 3d3d 0db7 20b5 16af . .... \==.. ...
00000030: 0db3 20b7 5f20 20b4 16af 0db1 20b4 5f0d .. ._ ..... ._.
00000040: 7c20 b1b2 5f20 7c0d 7cb1 b420 7c1b d9d2 | .._ |.|.. |...
00000050: af .
```
[Answer]
# [Julia](http://julialang.org/), ~~112~~ ~~108~~ 105 bytes
```
b"YEibUib-ad%ib=ad%ibMaduibUealmib%w=alb=/bu;m'bU#bfeSkefbfU%fbGG".|>b->print("\\
_= |¯"[b%8]^(b%88÷8))
```
[Try it online!](https://tio.run/##yyrNyUw0rPj/P0kp0jUzKTQzSTcxRTUzyRZM@iamlAIFUxNzcjOTVMttE3OSbPWTSq1z1ZNClZPSUoOzU9OS0kJV05Lc3ZX0auySdO0KijLzSjSUYmK44m0Vag6tV4pOUrWIjdMAkhaHt1toav7/DwA "Julia 1.0 – Try It Online")
each character of the string contains the next index of the character to print and the amount of it: `b%8` is the index of the character and `b%88÷8` is the amount (maximum 10)
the characters are generated as follows: `char = index + 8*amount + 88[if not printable]`
(very similar to [kaya3's answer](https://codegolf.stackexchange.com/a/224913/98541) and [Enzo's answer](https://codegolf.stackexchange.com/a/224863/91685))
[Answer]
# [JavaScript (Browser)](https://developer.chrome.com/docs/devtools/), 178 bytes
```
_='alert("~}}~ uw~}uw~w u}~su= ~{¯su=ysv¯y}xx_ vy}sx_y| xxxx |y|}}s |yvvvv")~zzyww {¯¯z\\\\y\\nx___w} v{{uz=s}w';for(i of'suvwxyz{}~')with(_.split(i))_=join(pop());eval(_)
```
Compressed using [RegPack](https://siorki.github.io/regPack.html). A lot of [JS1k](https://js1k.com/) submissions, including [mine](https://js1k.com/2017-magic/details/2704), went through RegPack to shave off some bytes.
[Answer]
# [Python 3](http://docs.python.org/3), 176 bytes
Fairly straightforward use of variables to repeat parts of the string. The only slightly clever parts are to do with spaces - the `print` function uses `' '` as a separator by default, so each `,` in the argument list for `print` results in a space, saving two bytes compared to `+s+` each time. The variables `v` and `w` are 3 and 8 spaces respectively, but `*v` with the unpacking operator results in 5 spaces.
I played around with it and found quite a lot of ways to make it 176 bytes, so there are probably a few more optimisations possible.
```
c,d,e,f,p,s,n='¯_=\\| \n'
a=f+f+n
b=f+e
v=s*3
w=s*8
print(w+a,w,a,v,b,v+a,*v,b,v+a+w,b+v+a+v+w+b+e+s,a,v+c*3,*v,b+e+n,*v,c*5+n+v+d*7+s,c*4+n,w,d*4+n+p,d*12,p+n+p,v,w,p+n+c*16)
```
[Try it online!](https://tio.run/##LYo7DsIwEAV7n4IusPuaEH6NbxIJxU4iaBYLR7aQuBN34GJmHdG8GT1NeC23h3SleIyYMCMgQmzz/Vxt3783vTRmsDPPLMYpJ5NspM5k3YsJz7ss28wDMgYkOCR1@gtnOK5MnNnxxLFG7KlbEz2kiqcjizYjnbXwdNA7Y6zkoGz3CKsmvat5ak@7Un4 "Python 3 – Try It Online")
[Answer]
# [///](https://esolangs.org/wiki////), 149 bytes
```
/0/¯¯¯//1/\\\\//2/ //3/22//4/__/3 11
2311
21= 211
31= 211
231= 11
23 1== 11
203 1==
30¯¯
2_444 0¯
3244
| 444444 |
| 33|
¯00000
```
[Try it online!](https://tio.run/##LY2xCQQxDARzV7EdrL1S6k4ezAUHH3zm1D1dD9eYXzpuhcRIDGj@jvk9596svK8ssvETIUUApFEinWPQgNYKZDmh1qOD7AUlPIrS7P3Vq@USXs0HRcPdgVjiJPey4E@wAmG2yn3VzN5/ "/// – Try It Online")
[Answer]
# Vyxal, ~~246~~ 103 bytes
[Try it online!](http://lyxal.pythonanywhere.com?flags=&code=%C2%BB%E1%BA%8A%E2%84%85%E1%B8%8A%E2%86%91%E2%86%B5S%E2%82%88q%E2%81%8B%CF%84GB%C2%A1%3A%E2%82%80%E1%BA%8E%C3%A6%E2%81%BD%E2%82%88%3B%E2%86%94%E2%89%AC%28%C9%BE%E2%82%86%5E%C2%BE%E2%88%91%E2%82%82%C4%A1L4%E1%BA%8A%3EX%C2%AF%5B%C2%B9%E2%80%9E%E2%81%8B%E2%88%B5%E2%9F%A8%E2%8C%88IR%E2%82%85%E2%8C%90%E2%88%91w%C4%A1b%E2%88%9AA%C3%B8%C4%8Ad%E2%96%A1%E2%89%A0%E2%9F%87%E2%85%9B%5D%E1%B9%AB%C2%AFG%C8%AEd%E2%86%93a%C2%AB%C7%8F%E1%B8%A31%E2%80%A69%E2%82%8DD%E2%82%ACCv%E2%86%94%E2%82%80%3Ay-%C2%BB%C2%BB%C3%B8%C2%BEq%C2%BB%60%20%5C%5C%3D%5C%C2%AF%7C_%0A%60%C4%BF&inputs=&header=&footer=)
```
»Ẋ℅Ḋ↑↵S₈q⁋τGB¡:₀Ẏæ⁽₈;↔≬(ɾ₆^¾∑₂ġL4Ẋ>X¯[¹„⁋∵⟨⌈IR₅⌐∑wġb√AøĊd□≠⟇⅛]ṫ¯GȮd↓a«Ǐḣ1…9₍D€Cv↔₀:y-»»ø¾q»` \\=\¯|_
`Ŀ
```
Had to escape the dashes because otherwise string commpression: also doubled backslashes because they also need escaping. Apart from that, pretty clear (Edit 1: significantly golfed)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~85~~ 84 bytes
```
•Ñ,ó r∍$±‘VY'ā±θʒć×zX[¬Ñˆãт²Ó₅ï=viÜLyƶ7eÖ¸¢¼“†…λ)’üƵĀÿ¹;ΣÃĀPJ¯12Q¦cI)Ù₄Í•"\
=¯_|"Åв
```
[Try it online!](https://tio.run/##AZkAZv9vc2FiaWX//@KAosORLMOzIHLiiI0kwrHigJhWWSfEgcKxzrjKksSHw5d6WFvCrMORy4bDo9GCwrLDk@KChcOvPXZpw5xMeca2N2XDlsK4wqLCvOKAnOKAoOKAps67KeKAmcO8xrXEgMO/wrk7zqPDg8SAUErCrzEyUcKmY0kpw5nigoTDjeKAoiJcIAo9wq9ffCLDhdCy//8 "05AB1E – Try It Online")
```
•...•"..."Åв # trimmed program
Åв # push list of characters in...
"..." # literal...
Åв # with indices in base-10 values of base length of...
"..." # literal...
Åв # digits of...
•...• # 598068322507306753885876761229106573443829774776514490536123134274531939033031756234422473798677424533439086479188876552508052865203429750266756699838477188150403473080434
# implicit output
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 90 bytes
```
“£RƊsƇCṄʠUU¿¦ȦC@Ṗṛ¡Ṛȧw²{MXI⁼ḊĊƑ(ḅyỴɲṫ^ȦhİA_ḳGḶµBṙnYɓ@ƑSṚ)ṇƲẋ.ubƓ9ṚIJɓɼÆÐƭ’ṃ“ \¶=_|”;175Ọ¤¤
```
[Try it online!](https://tio.run/##AbAAT/9qZWxsef//4oCcwqNSxopzxodD4bmEyqBVVcK/wqbIpkNA4bmW4bmbwqHhuZrIp3fCsntNWEnigbzhuIrEisaRKOG4hXnhu7TJsuG5q17IpmjEsEFf4bizR@G4tsK1QuG5mW5ZyZNAxpFT4bmaKeG5h8ay4bqLLnVixpM54bmaw4TCssmTybzDhsOQxq3igJnhuYPigJwgXMK2PV984oCdOzE3NeG7jMKkwqT////Crw "Jelly – Try It Online")
non-ascii in an ascii-art challenge is kinda sus
[Answer]
# [Vyxal 3](https://github.com/Vyxal/Vyxal/tree/version-3), 78 bytes
```
"ᶜᵛYn₄#D)∵#Ḟ→κ₀ḞɠṚR₂ᴿ₉
Ċ»+ḣᴿ
5²ᵂp-Ṣġ{8~ṀḌ∑₃ᶳÞ∥ċṢYʀQjĖ£ṁQ '√ċ₈%ı∧₈I1“"\
=¯_|"y
```
[Try it Online!](https://vyxal.github.io/latest.html#WyIiLCIiLCJcIuG2nOG1m1lu4oKEI0Qp4oi1I+G4nuKGks664oKA4bieyaDhuZpS4oKC4bS/4oKJXG7EisK7K+G4o+G0v1xuNcKy4bWCcC3huaLEoXs4fuG5gOG4jOKIkeKCg+G2s8Oe4oilxIvhuaJZyoBRasSWwqPhuYFRICfiiJrEi+KCiCXEseKIp+KCiEkx4oCcXCJcXCBcbj3Cr198XCJ5IiwiIiwiIiwiMy4yLjAiXQ==)
Can be golfed even better, any help would be greatly appreciated.
[Answer]
# [V (vim)](https://github.com/DJMcMayhem/V), 117 112 bytes
```
8á 2á\3Äj2é j4hi\= <esc>Ä}bb2é Äj2é 3lxÄj2é elr=ÄjelD9h3é¯ï7é 5á¯ï3é 7á_2á 4á¯ÙÒ $6X4á_ÙÒ_r|lr A |<esc>Ù<M-S>_/
ÙÒ¯
```
[Try it online!](https://tio.run/##K/v/3@LwQgWjwwtjjA@3ZBkdXqmQZZKRGWOrYJNanGx3uKU2KQkkCJUzzqmAslJzimyBzNQcF8sM48MrD60/vN4cKGx6eCGICRRRMD@8MB5oroIJWGjm4UkKKmYRQE48iB1fVJNTpOCoUAOxZqaNr26wXby@AhdI8tD6////65YBAA "V (vim) – Try It Online")
-5 bytes from DJMcMayhem.
This feels a bit too long for Vim, which I thought would work well for this challenge. I want to at the very least, beat one of the compressed answers.
] |
[Question]
[
Write the shortest code that traverses a directory tree and outputs a flat list of all files.
* It should traverse the whole directory tree
* The order in which it enters sub-directories doesn't matter
* The directories should not be output
* The output should be a plain list — the definition is flexible, but it shouldn't contain irrelevant data
* You are free to use any programming technique
[Answer]
# find 14 characters (12 on GNU)
```
find . -type f
```
Run this in the directory you want to list. Add `-printf '%f\n'` to only print names without the path.
Non-portable: `find -type f`.
[Answer]
# Pure Bash, 7
"ls -R" and "find" are the obvious, already mentioned common shell utilities. For completeness, we also have this pure bash option (no utility programs):
```
echo **
```
This requires the "globstar" shell option to be set with `shopt -s globstar`.
# Note:
This works only for Bash 4.0 and greater.
[Answer]
# Python
[Aleksi Torhamo's answer](https://codegolf.stackexchange.com/a/24195/5133) is the correct and idiomatic one. My answer is just an exercise of what if there was no [`os.walk`](http://docs.python.org/2/library/os.html#os.walk).
I was inspired by an elegant [recursive function](https://stackoverflow.com/a/1684795/596361) for Emacs Lisp that does the same.
```
from os import *
from os.path import *
def walk(path):
return [basename(f) for f in listdir2(path) if not isdir(f)] +\
sum([walk(f) for f in listdir2(path) if isdir(f)], [])
```
`listdir2` here is a non-existent function that returns absolute paths of files in a directory. Unfortunately, `listdir` [doesn't return absolute paths](https://stackoverflow.com/a/15452633/596361), therefore i had to manually enter and exit directories with `chdir`, so my result wasn't a slick one-liner.
```
from os import *
from os.path import *
def walk(path, old_path):
chdir(path)
result = [f for f in listdir(path) if not isdir(f)] +\
sum([walk(join(path, f), getcwd()) for f in listdir(path) if isdir(f)], [])
chdir(old_path)
return result
```
To understand it you must read about [`os.chdir`](http://docs.python.org/2/library/os.html#os.chdir), [`os.getcwd`](http://docs.python.org/2/library/os.html#os.getcwd), [`os.listdir`](http://docs.python.org/2/library/os.html#os.listdir), [`os.path.isdir`](http://docs.python.org/2/library/os.path.html#os.path.isdir), [`os.path.basename`](http://docs.python.org/2/library/os.path.html#os.path.basename), [`os.path.join`](http://docs.python.org/2/library/os.path.html#os.path.join), [`sum`](http://docs.python.org/2/library/functions.html#sum). The function creates a list of files and recursively repeats this for sub-directories. The list of sub-directories is summed up and appended to the list of original files.
We iterate thru list 2 times, this is inefficient. Better to partition the list into files and directories in one go. [This answer](https://stackoverflow.com/a/4579086/596361) proposes a smart use of `reduce`:
```
reduce(lambda x, y: x[not p(y)].append(y) or x, l, ([], []))
```
# Attempt #1 (~~179~~ 171)
```
from os import*
def w(p,o):chdir(p);r=[f for f in listdir(p)if not path.isdir(f)]+sum([w(path.join(p,f),getcwd())for f in listdir(p)if path.isdir(f)],[]);chdir(o);return r
```
# Attempt #2 (~~190~~ 178)
```
from os import *
def u(p,o):chdir(p);a,b=reduce(lambda x,y:x[path.isdir(y)].append(y)or x,listdir(p),([],[]));r=a+sum((u(path.join(p,c),getcwd())for c in b),[]);chdir(o);return r
```
[Answer]
# DOS (11 characters)
`dir/s/b/a-d`
I love the simplicity, `/s` allows `dir` to traverse through all subfolders, while `/b` suppresses the header and directory information. `/a-d` suppresses outputting of directories. A quick check to see if the additional space was required, and I was happy enough to submit this...
[Answer]
# Python3 - 53 characters
Two equally long ways for doing it:
```
import os;print(*sum((x[2]for x in os.walk('.')),[]))
```
and
```
import os;print(*sum(list(zip(*os.walk('.')))[2],[]))
```
These print the filenames separated by spaces on one line, I assumed that counts as a "flat list".
[Answer]
# C - 203 194
This example works when compiled with TCC:
```
t(char*p){DIR*d;struct dirent*e;if(d=opendir(p))while(e=readdir(d)){char*n=e->d_name,f[PATH_MAX];sprintf(f,"%s/%s",p,n);if((*n++-46|*n&(*n++-46|*n))&&!t(f))printf("%s\n",f);}return!closedir(d);}
```
This recursive function displays the path of every file present in the folder which path has been given as a parameter.
*Note:* one character had to be added to get the same result with GCC:
```
int t(char*p){DIR*d;struct dirent*e;if(d=opendir(p))while(e=readdir(d)){char f[PATH_MAX];char*n=e->d_name;sprintf(f,"%s/%s",p,n);if((*n++-46|*n&&(*n++-46|*n))&&!t(f))printf("%s\n",f);}return!closedir(d);}
```
I replaced `&` with `&&` in the condition. I guess the `&` operator has priority over `&&` in TCC syntax, while the opposite occurs with GCC.
See the full working example here: <http://ideone.com/lGBtJw>
# C - 220 215 (full program with include)
I liked that Coaumdio used a full program to answer... so I started adapting mine, here is the result:
```
#include<dirent.h>
main(i,char**p){DIR*d=opendir(*++p);char*n,f[4096],*a=f;struct dirent*e;d||puts(*p);if(d)while(e=readdir(d))sprintf(f,"%s/%s",*p,n=e->d_name),(*n++-46|*n&&(*n++-46|*n))&&main(i,&a-1);closedir(d);}
```
Expanded version:
```
#include<dirent.h>
int main(int i,char**p){
DIR*d=opendir(*++p);
char f[4096],*n,*a=f;
struct dirent*e;
d||puts(*p);
if(d)while(e=readdir(d))
sprintf(f,"%s/%s",*p,n=e->d_name),
(*n++-46|*n&&(*n++-46|*n))&&main(i,&a-1);
closedir(d);
}
```
Usage:
```
gcc list_files.c -o list_files
./list_files /var
```
[Answer]
**Bash**, 18
```
ls -R
```
**Windows CMD.**
```
dir /S
```
Compliant version
```
ls -R1|grep -v ^./
```
[Answer]
# C, 216 228 chars (#include included)
The other C solution contians nice tricks, but as I like compilable complete C solutions, here is my shot:
```
#include <dirent.h>
main(int _,char**v){char n[4096],*a=n,*b;DIR*d;struct dirent*e;(d=opendir(*++v))||puts(*v);while(d&&(e=readdir(d)))b=e->d_name,sprintf(n,"%s/%s",*v,b),strcmp(".",b)&&strcmp("..",b)&&main(0,&a-1);}
```
It's also a recursive traversal algorithm, and it's using the `main` function as recursive function. The main function tries to open the path contained in `argv[1]`. If it fails, it prints it, otherwise, it calls main on every sub-element (if it's different from `"."` or `".."`).
## Usage
It's a standalone, working C program:
```
$ gcc dir.c -o dir
$ ./dir /var.log
/var/log/kern.log.1
/var/log/alternatives.log.1
/var/log/user.log.2.gz
/var/log/nvidia-installer.log
/var/log/debug.4.gz
/var/log/wtmp.1
/var/log/lastlog
/var/log/messages.2.gz
/var/log/vmware-installer
/var/log/pm-powersave.log
/var/log/syslog.4.gz
/var/log/news/news.err
/var/log/news/news.notice
/var/log/news/news.crit
/var/log/apt/history.log.3.gz
/var/log/apt/history.log.9.gz
/var/log/apt/history.log.4.gz
/var/log/apt/term.log.10.gz
/var/log/apt/history.log.10.gz
/var/log/apt/term.log.4.gz
```
## Tips
I used a few (somewhat classic) C tricks:
* replace `if(condition)statement` with `contition && statement`
* replace `if(!condition)statement` with `condition || statement`
* use the `,` operator to save `{` and `}` in the while code
Here is a readable version:
```
#include <dirent.h>
main(int _,char**v) {
char n[4096], *a=n,*b;
DIR *d;
struct dirent *e;
(d = opendir(*++v)) || puts(*v);
while(d && (e = readdir(d)))
b = e->d_name,
sprintf(n, "%s/%s", *v, b),
strcmp(".", b)&&strcmp("..", b)&&
main(0, &a-1);
}
```
## Edit
I have to insert a `closedir(d);` statement at the end, because a limit is reached when too much folders are opened (wild guess: the *open files* limit) and the the program stops. This happens only for folder containing many other folders.
the code is now:
```
#include <dirent.h>
main(int _,char**v){char n[4096],*a=n,*b;DIR*d;struct dirent*e;(d=opendir(*++v))||puts(*v);while(d&&(e=readdir(d)))b=e->d_name,sprintf(n,"%s/%s",*v,b),strcmp(".",b)&&strcmp("..",b)&&main(0,&a-1);closedir(d);}
```
[Answer]
## Groovy 58
```
new File("/").eachFileRecurse(){if(it.isFile())println it}
```
[Answer]
### CMD - 32 Bytes
Another CMD / DOS method -
```
for /r %a in (*)do @echo %~dpnxa
```
The `/r` switch recursively looks through a directory (defaulting to current directory), while `%~dpnxa` outputs `%a`, the current directory or file in the loop, to the following output format -
`d` - drive
`p` - path
`n` - name
`x` - extension
Because `x` is specified it will only output files, ignoring directories.
[Answer]
# Groovy 45
Now even shorter:
```
new File(".").traverse{if(it.file)println it}
```
Uses one of the [traverse() methods](http://docs.groovy-lang.org/latest/html/groovy-jdk/java/io/File.html#traverse(java.util.Map,%20groovy.lang.Closure)) available since Groovy 1.7.1.
# Groovy 46 ;-)
Another nice solution, if you don't count the required `import` statement, is this one:
```
import groovy.io.FileType.*
new File(".").traverse type:FILES,{println it}
```
[Answer]
# Ruby 18 characters
```
puts Dir['./**/*']
```
[Answer]
# Java 11, 52 bytes
```
Files.list(Path.of("")).forEach(System.out::println)
```
# Java, 87 bytes
```
void t(File f){if(f.isFile())System.out.println(f);else for(File c:f.listFiles())t(c);}
```
[Answer]
# SmileBASIC, 78 bytes
```
DIM F$[0],D$[0]FILES"//",D$@L
FILES POP(D$),F$WHILE LEN(F$)?POP(F$)WEND
GOTO@L
```
Displays a `*` or before each filename, depending on whether it's a text file (is this allowed?)
] |
[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/133003/edit).
Closed 6 years ago.
[Improve this question](/posts/133003/edit)
The infinity symbol is also called a lemniscate. Your program must draw a lemniscate with text via standard out (formatted with newline feeds) or graphically.
The infinity symbol (by my standards) must be continuous (that is, every non-whitespace character must be touching two other non-whitespace characters diagonally or orthogonally). It must also have two and no more than two gaps of enclosed whitespace (connectivity for whitespace is only orthogonal). Thus, the following output fails:
```
ooo ooo
o o o o
o o o
o o o o
ooo ooo
```
A correct version the above example might be
```
oooo oooo
o o o o
o o o
o o o o
oooo oooo
```
or
```
ooo ooo
o o o o
o o o
o o o o
ooo ooo
```
The size of the ∞ is unimportant. The orientation of the ∞ is unimportant. Symmetry is also unimportant. Graphical displays are accepted as well. Appropriate newline feeds are required in the output.
This is a [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") question so answers will be scored in bytes, with less bytes being better.
[Answer]
# Desmos, 22 bytes
```
r=\sqrt{\sin 2\theta }
```
[Try it here!](https://www.desmos.com/calculator/4v2mrzgzcp) Desmos is a graphing tool. This plots the polar equation:
[![r = sqrt[sin 2 theta]](https://i.stack.imgur.com/5fjHy.gif)](https://i.stack.imgur.com/5fjHy.gif)
which draws a lemniscate shape.
[Answer]
# J, 8 bytes
```
3 5$' o'
```
Like Conor's, prints:
```
o o
o o o
o o
```
`$` is J's shape operator, so we are creating a 3 x 5 grid, using the fill chacters `o`. When fill runs out, `$` repeats them cyclically by default.
[Try it online!](https://tio.run/##y/r/PzU5I1/BWMFURV0hX/3/fwA "J – Try It Online")
[Answer]
# Mathematica, 4 bytes
```
∞&
```
I think this answer covers all the criteria
# Mathematica, 17 bytes
```
Graphics@Text@∞
```
@ovs's opinion is that the right answer is...
# Mathematica, 2 bytes
```
8&
```
and I agree!
[Answer]
# Mathematica - 49 bytes
```
ParametricPlot[{ReIm[Sin[t+I Sin[t]]]},{t,0,2Pi}]
```
Result:
[](https://i.stack.imgur.com/VgbeX.jpg)
[Answer]
# [///](https://esolangs.org/wiki////), 13 bytes
```
/z/ o o
/zozz
```
[Try it online!](https://tio.run/##K85JLM5ILf7/X79KXyFfIZ9Lvyq/qur/fwA "/// – Try It Online") Outputs:
```
o o
o o o
o o
```
I think this is the smallest valid "lemniscate" allowed by the rules.
[Answer]
# [Python 2](https://docs.python.org/2/), ~~21~~ 19 bytes
```
print"o o\nooo\n"*3
```
[Try it online!](https://tio.run/##K6gsycjPM/r/v6AoM69EKV8hPyYvPx9IKGkZ//8PAA "Python 2 – Try It Online")
This prints:
```
o o
ooo
o o
ooo
o o
ooo
```
It may not look like a lemnescate but it has two enclosed spaces (marked with `x`)
```
o o
ooo
oxo
ooo
oxo
ooo
```
And every `o` is connected to at least two other `o`s. Thus despite not looking anything like what it is supposed to this fulfills the bare-minimum requirements.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~8~~ 7 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
8RKḊs5Y
```
As a full program prints:
```
2 3
4 5 6
7 8
```
Which seems to adhere to the specification.
**[Try it online!](https://tio.run/##y0rNyan8/98iyPvhjq5i08j///8DAA "Jelly – Try It Online")**
### How?
```
8RKḊs5Y - Main link: no arguments
8R - range of 8 -> [1,2,3,4,5,6,7,8]
K - join with spaces -> [1,' ',2,' ',3,' ',4,' ',5,' ',6,' ',7,' ',8]
Ḋ - dequeue -> [' ',2,' ',3,' ',4,' ',5,' ',6,' ',7,' ',8]
s5 - split into chunks of length 5 -> [[' ',2,' ',3,' '],[4,' ',5,' ',6],[' ',7,' ',8]]
Y - join with newlines -> [' ',2,' ',3,' ',`\n`,4,' ',5,' ',6,'\n',' ',7,' ',8]
- implicit print
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 9 bytes
```
o↘ooo‖Ｂ¬←
```
Draws the actual last example. 10-byte version that takes a size parameter as input:
```
Ｇ→↘↘Ｎo‖Ｂ¬←
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z8gP6cyPT9PwyooMz2jREfByiW/PA8L2zOvoLTErzQ3KbVIQ1NHQSlfSdOaKyg1LSc1ucSptKQktSgtp1LD6tAaoDaf1LQSTev//43@65b91y3OAQA "Charcoal – Try It Online") Link is to verbose version of code.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 7 bytes (ASCII-art version)
```
ＧＨX²o‖Ｂ
```
[Try it online!](https://tio.run/##ARwA4/9jaGFyY29hbP//77yn77yoWMKyb@KAlu@8ov// "Charcoal – Try It Online")
The first part (`ＧＨX²o`) prints a hollow polygon of size 2 in the `X` direction using the `o` char as border, that results in this:
```
o
o o
o
```
Then I only have to reflect the canvas horizontally (skipping the middle column), to get this:
```
o o
o o o
o o
```
Link to the [verbose version](https://tio.run/##S85ILErOT8z5/z8gP6cyPT/PIz8nJ79cwypCR8FIR0EpX0nTmisoNS0nNbnEqbSkJLUoLadSQ9P6////umX/dYtzAA).
[Answer]
**C , 55 bytes**
```
i;f(){while(i++<18)putchar(i%6?(i/6+i)%2?32:'o':'\n');}
```
outputs
[](https://i.stack.imgur.com/5Ox27.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/33257/edit).
Closed 9 years ago.
[Improve this question](/posts/33257/edit)
There are a lot of challenges on this site regarding pi, but none that challenge you to calculate as many digits of pi as possible.
As you all may know, pi in its decimal form goes on for infinity, so calculating it in its entirety is near to impossible. However, I challenge you to write a program in your language of choice that can calculate as many digits of pi as possible, and ***include an explanation with your code.*** The winner will be decided by popularity contest.
The only restriction is that your program cannot connect to the internet. The point is not to have your program search the internet for the most digits of pi.
So in summary, the goal is to write a program that computes as many digits of pi as possible (in decimal, so 3.14159....). Your program cannot simply connect to the internet and lookup digits, it needs to calculate it.
**Note here that the goal here is to calculate as many digits as possible, but that is not the winning criteria. The winner will be based on popularity (number of upvotes).** Remember, we're here to learn just as much as to have fun.
Winner will be decided on July 16 at 10 AM eastern time.
And please, don't be [this guy](http://www.dailymail.co.uk/sciencetech/article-2051950/Obsessed-mathematicians-spend-year-calculating-trillionth-digit-Pi-5-way.html). Let's have fun.
[Answer]
# C
The following is my favourite implementation of a pi calculation program:
```
#define _ F-->00 || F-OO--;
long F=00,OO=00;
main(){F_OO();printf("%1.3f\n", 4.*-F/OO/OO);}F_OO()
{
_-_-_-_
_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_
_-_-_-_
}
```
Found [here](https://www.cise.ufl.edu/~manuel/obfuscate/obfuscate.html) with the following explanation:
>
> Pi -- A unique program layout and the most unusual method of calculating pi I have ever seen. The source code is a circle and the program works by calculating its own area and diameter, and then doing a division to approximate pi!! Very bizzare.
>
>
>
I haven't tried this, but I guess you can make the circle larger to calculate more digits of pi.
[Answer]
## Mathematica
I'm definitely going for the simplicity/golf award here with 5 characters:
```
π~N~n
```
Just defined `n` to be the number of digits you want.
I did a quick test to figure out how many digits that allows me to calculate within a week. I ran this for `n` from 100 000 to 10 000 000 in steps of 100 000 and measured the time. The plot looks *very* much linear (apart from a few outliers, because I used my machine during the test), so I got a least squares fit for a linear function, solved it for `n` and plugged in `t = 60*60*24*7`. On my 3 year-old laptop, I'd get about **4.5 \* 1011** digits, which is 450 billion. Realistically it might be a bit less, as I can't predict whether the algorithm used by Mathematica will at some point slow down, e.g. due to memory or cache constraints.
[Answer]
## C - 13 million digits
```
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#define DIGITS 13000000
int main() {
uint64_t d=0,h=1e9;
uint32_t b,c=30*((DIGITS+25)/9),e=0,g;
uint32_t* f=(uint32_t*)malloc(4*c);
while(b=c-=30){
while(--b){
d=d*b+h*(e?f[b]:2);
f[b]=d%(g=2*b-1);
d/=g;
}
printf(e?"%09d":"%d.",e+d/h);
e=d%h;
}
free(f);
return 0;
}
```
Using only standard libraries, compiled with `gcc -O2`. The formula used is the following:
This can be derived directly from the Leibniz Series, as can be [seen elsewhere](https://codegolf.stackexchange.com/a/18988). Standard long division is used, in base *1000000000* rather than base *10*, storing the remainders for each division in an array.
The algorithm is quadratic: *10000* digits takes ~0.35s, *100000* takes ~35s, etc (*10* times as many takes *100* times as long). I estimate that all *13000000* will take approximately 6d 20h 18m, give or take, using a constant 170MB of memory.
[Answer]
## C# - 412 394 chars, 3000 digits, 7 seconds
I wrote this program myself, except for the square root function.
It calculates π using the Chudnovsky formula and uses the .Net BigInteger class for fixed-point math.
```
using B=System.Numerics.BigInteger;class M{static void Main(){B f=B.Pow(10,3000);B z=0;for(int k=0;k<220;k++)z+=f*F(6*k)*(13591409+545140134*new B(k))/(F(3*k)*B.Pow(F(k),3)*B.Pow(-640320,3*k));System.Console.WriteLine(f*f/(12*z*f/S(B.Pow(640320,3)*f*f)));}static B F(B N){return(N.Sign>0)?N*F(N-1):1;}static B S(B N){if(0==N)return 0;B o=(N>>1)+1;for(B a=o+N/o>>1;a>1)o=a;return o;}}
```
With some extra white space:
```
using B=System.Numerics.BigInteger;
class M{
static void Main(){
B f=B.Pow(10,3000);
B z=0;
for(int k=0;k<220;k++)
z+=f*F(6*k)*(13591409+545140134*new B(k))/(F(3*k)*B.Pow(F(k),3)*B.Pow(-640320,3*k));
System.Console.WriteLine(f*f/(12*z*f/S(B.Pow(640320,3)*f*f)));
}
static B F(B N){return(N.Sign>0)?N*F(N-1):1;}
static B S(B N){if(0==N)return 0;B o=(N>>1)+1;for(B a=o+N/o>>1;a>1)o=a;return o;}}
```
The Main function calculates Pi, and the other 2 functions are (respectively) Factorial and Square Root.
The number of digits (3000) can be changed in the Main function, just be sure to change the number of Chudnovsky terms (220) to match, otherwise some digits will be incorrect.
It takes about 7 seconds to run on my computer right now.
] |
[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/20154/edit).
Closed 5 years ago.
[Improve this question](/posts/20154/edit)
This is similar to a [previous question on this site](https://codegolf.stackexchange.com/questions/5194/rotate-an-ascii-art-image?rq=1), but with much simpler rules, so we should get much shorter results (in bytes):
* **Input:** ASCII art with only *two* possible characters: space and '#'.
* **Output:** Input sequence rotated 90 degrees counter-clockwise.
Winner is answer with least number of bytes including length of language name.
[Answer]
# K, 1+1
```
+
```
.
```
k)+("# # #";" # # ";"#####")
"# #"
" ##"
"# #"
" ##"
"# #"
```
[Answer]
## GolfScript (10 chars + 10)
```
n/zip-1%n*
```
[Online demo](http://golfscript.apphb.com/?c=OycjICMgIwogIyAjIAojIyMjIycKbi96aXAtMSVuKg%3D%3D)
Note: as Tomas correctly observed in the comments, I'm assuming that the input is rectangular. This seems reasonable, because it is explicitly stated in the specification of the question which this one aims to simplify.
[Answer]
# MATLAB - 14
```
rot90(a)
```
Where 'a' is the input art, in matrix form.
8 characters in the code, 6 in the name. 8 + 6 = 14.
[Answer]
## J, 16+1 characters
```
|.|:[;._2[1!:1[3
```
Usage (first 3 lines of `#` is the input, the rest is the output):
```
|.|:[;._2[1!:1[3
# # #
# #
#####
# #
##
# #
##
# #
```
**Explanation:**
`1!:1[3` take multi-line input from the keyboard
`[` used as a separator
`[;._2` chop the string into lines
`|:` transpose
`|.` reverse
12 characters to take an process the input, and 4 characters to complete the task.
[Answer]
**Python 3.X 56-Chars**
```
print('\n'.join(map(''.join,zip(*input().split('\n')))))
```
**Demo**
```
>>> print '\n'.join(map(''.join,zip(*raw_input().split('\n'))))
# # #
# #
#####
# #
##
# #
##
# #
# ## # #
## # #
# ######
##
# #
```
[Answer]
# R, 4+1
```
t(a)
```
Where 'a' is the input art, in matrix form. Language is Cran R, function to transform/rotate a martix is t.
[Answer]
# Ruby 56
```
s=[*$<];s[0].size.downto(1){|i|puts s.map{|l|l[i-1]}*''}
```
[Answer]
# Perl, 44 chars
```
$/=$i--;$_=<>;say/(.).{$i}$/gmwhile!++$i||$1
```
Assuming all rows have equal length.
[Answer]
# J (4+1)
```
|:|.
```
Expected input as a string matrix. Usage:
```
a=: >'# # #';' # #';'#####'
a
# # #
# #
#####
|:|.a
# #
##
# #
##
# #
```
[Answer]
## Bash ~~(144 + 4)~~ (131 + 4)
Assumes input is in a file with newlines to delimit end of row.
Assumes each row has the same number of characters.
Assumes first argument is path to file.
```
t=`sed 's/\(.\)/\1\t/g' $1` n=$(expr $(head -n1 $1|wc -c) \- 1);for i in $(seq 1 $n);do echo "$t"|cut -f$i|tac|tr -d '\n';echo;done
```
Un-golfed:
```
t=$(sed 's/\(.\)/\1\t/g' $1) # Add a tab after every character.
n=$(expr $(head -n 1 $1 | wc -c) \- 1) # Count the number of characters in a row.
for i in $(seq 1 $n); do # For each row.
echo "$t"|cut -f "$i" |tac|tr -d '\n' # Cut the i^th column, print, reverse and delete newline.
echo # Finished processing i^th row. Emit newline.
done
```
[Answer]
# JavaScript (ES6), 83
```
f=(s,o=[],a='')=>/./.test(s)?f(s.replace(/^./gm,x=>(a=x+a)&&''),[...o,a]):o.join`\n`
G.onclick=g=>X.innerHTML=f(X.innerHTML)
```
```
textarea{
height:100px;
line-height:7px;
}
```
```
<button id=G>Rotate</button>
<textarea id=X>
#
# #
# #
# #
# #
# #
# #
# #
# #
# #
#
</textarea>
```
] |
[Question]
[
**This question already has answers here**:
[Different Way Forward](/questions/47005/different-way-forward)
(31 answers)
Closed 2 years ago.
Given a list of integers, such as `{1, 4, 2, 8, 10}`, TI-Basic's `ΔList` will determine the difference between every overlapping pair of items. In the given example, it would be `{3, -2, 6, 2}`.
**Task:**
Take a list of integers as input, in any reasonable way. All overlapping pairs `{x, y}` should become `y - x`, and the resulting list returned. It should always be one item shorter. You can assume the list will never be shorter than two items.
**Test cases:**
```
{1, 2} {1}
{1, 2, 4} {1, 2}
{2, 1} {-1}
{2, 2, 2} {0, 0}
{-1, 0, 0, -1} {1, 0, -1}
{0, 1, 2, 1, 1, 0} {1, 1, -1, 0, -1}
```
**Other:**
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"). Shortest answer (in bytes) per language wins!
[Answer]
# [V (vim)](https://github.com/DJMcMayhem/V), ~~33 26~~ 25 bytes
```
qqjYkPJr-0C<c-r>=<c-r>"
<Esc>j@qq@qdd
```
[Try it online!](https://tio.run/##K/v/v7AwKzI7wKtI18DZJlm3yM4WTCpx2bgWJ9tlORQWOhSmpPz/b8Bl@F@3DAA "V (vim) – Try It Online")
Input as a newline separated list of integers.
-7 bytes from kops.
-1 more byte from kops.
## Explanation
```
qqjYpkk:s/\n/-
qq start macro q
jYp go down and duplicate the second line from the cursor
kk move back to the original position
:s/\n/- replace newline with -
Current Line: n1-n2
C<c-r>=-(<c-r>")
C cut current line, enter insert mode
<c-r>= evaluate the following
-(<c-r>") negate n1-n2
<Esc>j@qq@qdd
<Esc> exit insert mode
j go 1 step down to the next values
@qq recursively call macro q and end macro
@q call macro q
dd delete last extra line
```
[Answer]
# Trivial answers
# [05AB1E](https://github.com/Adriandmen/05AB1E), 1 byte
```
¥
```
[Try it online!](https://tio.run/##yy9OTMpM/f//0NL//6MNdRSMdBRMYgE "05AB1E – Try It Online")
# [R](https://www.r-project.org/), 4 bytes
```
diff
```
[Try it online!](https://tio.run/##K/qfYvs/JTMt7X@KRrKGoY6JjpGOhY6hgabmfwA "R – Try It Online")
# [Jelly](https://github.com/DennisMitchell/jelly), 1 byte
```
I
```
[Try it online!](https://tio.run/##y0rNyan8/9/z/8Odix81zK19uGPRwx1dD3fMf9S4Lexw@9FJD3fO4Hq4e8vh9kdNayL//6821FEwqlXAANWGtVxgOR0Fk1oMOZAermqgnCE2rbqGEEkjLEZXG@goGACldYFmGICRLrIZ1YYwMS6QSogDDMHIoBahxBCkBKYSAA "Jelly – Try It Online")
Feel free to add your answers here.
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 82 bytes
```
\d+
$*
¶.*
$&-$%`
^.*¶
%(`^((-1+)|(1*)-)-(1*)$
$2$3$4
(1*)-+\1
-
--|-$
1`1*$
$.&
```
[Try it online!](https://tio.run/##HYzLCcNADETvU4fW7EdaVhv3kAJyNUaB5JBLDiFH1@UC3NhGDo/HwAzM5/l9ve8jxJvxWB4FlHHsNYMmoWBYaz52IERbYxQtaYuakyQ5g0CdLjTj35VFIRDZhAA1zT7XaaSr@SN4KHe4PKOzug5EuTmiaHxu6rQf "Retina 0.8.2 – Try It Online") Takes input on separate lines but test suite converts from and to comma delimited for convenience. Explanation:
```
\d+
$*
```
Convert to unary.
```
¶.*
$&-$%`
```
Create expressions for the differences of successive terms. `$%`` grabs the previous term without having to match it.
```
^.*¶
```
Delete the first term.
```
%(`
```
Perform the rest of the script individually on each subtraction.
```
^((-1+)|(1*)-)-(1*)$
$2$3$4
```
If the two values have different signs then negate the second and add it to the first.
```
(1*)-+\1
-
```
Otherwise subtract the two values.
```
--|-$
```
The subtraction can result in a double negative or a trailing subtraction of zero which needs to be removed.
```
1`1*$
$.&
```
Convert to decimal.
[Answer]
# JavaScript (ES6), 32 bytes
```
a=>a.slice(1).map((v,i)=>v-a[i])
```
[Try it online!](https://tio.run/##bY5BDsIgEEX3noIlJEA7jVt6kaYLgtRgsDTWsDGeHYFWo8JkVp/3hn@RXq7qZpY7m91Jh0kEKXrJV2uUxkD4VS4Ye2qI6D2TgxlJUG5endXcujOe8AAUdSMh6HuaBj3geaiQFB1/4EzGvIAjCbWzDGpo918ioS1FaQuewfZAEft8sffIWSHEdOsOedsk7QIk4e2FFw "JavaScript (Node.js) – Try It Online")
---
### JavaScript (ES6), 33 bytes
```
a=>a.map(v=>-p+(p=v),p=a.shift())
```
[Try it online!](https://tio.run/##bY5BDsIgEEX3noIlRKCdxi29iHFBatGaWkhp2BjPjkCrUWEyq897w79JJ203D2Zhkz73XgkvRSv5XRrsRMvMHhvhCDVCcnsd1IIJ8Z2erB57PuoLVvgIFDUnQtD3VBV6wHNXICk6/MCJDHkGBxJKZxmU0Oa/RERriuJmPIP1gSL2@WLrkbJMCOnaHdLWUdoEiMLb8y8 "JavaScript (Node.js) – Try It Online")
### JavaScript (ES10), 34 bytes
```
a=>a.flatMap((v,i)=>i?v-a[i-1]:[])
```
[Try it online!](https://tio.run/##bY5BDoMgEEX3PQVLSEAd01UT7Al6AsNiYrWhMWLUsGl6dgpom7Y4mdXnveHf0eLcTHpcxGCureukQ1lh1vW4XHCk1HLNZKXPVmCtBahTrZhrzDCbvs16c6MdrYGTUjFGvifPyQOehx2Sk@MPHEmfJ7AnYe@sgD20/C8R0IKTsAkvYH3gRHy@2HrELBF8unaHuEWQNgGC8PbcCw "JavaScript (Node.js) – Try It Online")
[Answer]
# APL 5 bytes
```
2-⍨/⎕
⎕ ⍝ input
-⍨ ⍝ reversed subtraction
2 / ⍝ between every 2 elements like [1,2,3] -> [1 f 2, 2 f 3]
```
[try it online](https://abrudz.github.io/ngn-apl/web/index.html#code=%u2395%u21902-%u2368/%u2395)
[Answer]
# [Python 3](https://docs.python.org/3/), 38 bytes
```
lambda s:[y-x for x,y in zip(s,s[1:])]
```
[Try it online!](https://tio.run/##K6gsycjPM/6fZhvzPycxNyklUaHYKrpSt0IhLb9IoUKnUiEzT6Eqs0CjWKc42tAqVjP2f0FRZl6JRppGtIGOgqGOghGYBCKDWE3N/wA "Python 3 – Try It Online")
-8 bytes thanks to @cairdcoinheringaahing
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 10 bytes
```
ＩＥΦθκ⁻ι§θκ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMM5sbhEwzexQMMtM6cktUijUEchW1NHwTczr7RYI1NHwbHEMy8ltQIiDgLW//9HRxvqKJjoKBjpKFjoKBgaxMb@1y3LAQA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
θ Input array
Φ Filtered where
κ Current index is not zero
Ｅ Map over remaining elements
ι Current element
⁻ Subtract
θ Input array (still with zeroth element)
§ Indexed by
κ Current index
Ｉ Cast to string
Implicitly print
```
[Answer]
# [Haskell](https://www.haskell.org/), 17 bytes
```
zipWith(-)=<<tail
```
[Try it online!](https://tio.run/##bY7BDoIwDIbve4rGmABxU2a8yXwC7x7mDgsOWRy4yA7gwzs3CNFEm17a7@@X1rK7KWN8xc7@qe1JuzolGSsKJ7XxjdQtu9wRpBrfs4JUjbQQybqzsk03LBFJViwPV@WOulUIjHLQs4eSl6VerRZisR/GCYLDPnTr0ipwNuAeDxmC6PecYtgK@ClOBRoZhp34YfEG8cDov1NCJ7j9o@Y5hjxgEhz52OTbwem8QzE5PUDHzsUnQmNkTr7Kyshr50lp7Rs "Haskell – Try It Online")
[Answer]
# [R](https://www.r-project.org/), 25 bytes
```
head((x=scan())[-1]-x,-1)
```
[Try it online!](https://tio.run/##K/r/PyM1MUVDo8K2ODkxT0NTM1rXMFa3QkfXUPO/oYKJgpGChYKhwX8A "R – Try It Online")
The [R](https://www.r-project.org/) 'trivial' answer is `diff` (difference).
So this is my attempt at the golfiest solution *without* diff...
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 2 bytes
```
IƝ
```
[Try it online!](https://tio.run/##y0rNyan8/9/z2Nz///8b6CgY6igYgUkgMgAA "Jelly – Try It Online")
Full program, as it relies on Jelly's outputting format.
This applies `I` (forward differences) to each overlapping pair `[x, y]` (`Ɲ`), yielding `[y - x]` for each. Due to Jelly's printing, as a full program, it omits the brackets around single element lists, so the output looks like a flat list.
# [Jelly](https://github.com/DennisMitchell/jelly), 3 bytes
Non-builtin approaches. All are functions
```
_ƝN
```
[Try it online!](https://tio.run/##y0rNyan8/z/@2Fy//w93Ln7UMLf24Y5FD3d0Pdwx/1HjtrDD7UcnPdw5g@vh7i2H2x81rYn8/7/aUEfBqFYBA1Qb1nKB5XQUTGox5EB6uKqBcobYtOoaQiSNsBhdbaCjYACU1gWaYQBGushmVBvCxLhAKiEOMAQjg1qEEkOQEphKAA "Jelly – Try It Online")
```
_@Ɲ
```
[Try it online!](https://tio.run/##y0rNyan8/z/e4djc/w93Ln7UMLf24Y5FD3d0Pdwx/1HjtrDD7UcnPdw5g@vh7i2H2x81rYn8/7/aUEfBqFYBA1Qb1nKB5XQUTGox5EB6uKqBcobYtOoaQiSNsBhdbaCjYACU1gWaYQBGushmVBvCxLhAKiEOMAQjg1qEEkOQEphKAA "Jelly – Try It Online")
```
IƝF
```
[Try it online!](https://tio.run/##y0rNyan8/9/z2Fy3/w93Ln7UMLf24Y5FD3d0Pdwx/1HjtrDD7UcnPdw5g@vh7i2H2x81rYn8/7/aUEfBqFYBA1Qb1nKB5XQUTGox5EB6uKqBcobYtOoaQiSNsBhdbaCjYACU1gWaYQBGushmVBvCxLhAKiEOMAQjg1qEEkOQEphKAA "Jelly – Try It Online")
## How they work
They all use the `Ɲ` quick, which takes a link before it (a command, usually an atom) and a list, and applies the link to all overlapping pairs in the list.
`_` is subtraction in Jelly, and `@` reverses the order of the arguments to the previous link.
The first one calculates `x - y` for each overlapping pair, then negates each.
The second calculates `x -@ y` for each overlapping pair, which is equivalent to `y - x`
The third applies `I` (forward differences) to each pair, yielding `[y - x]`. We then flatten this into a single array.
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 11 bytes
```
Differences
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n2773yUzLS21KDUvObX4f0BRZl6JgkO6Q7WBjoKhjoIRmAQig9r//wE "Wolfram Language (Mathematica) – Try It Online")
] |
[Question]
[
This is similar to [this question](https://codegolf.stackexchange.com/questions/111287/solve-the-new-york-times-spelling-bee).
However, I have a different goal in mind:
Reduce the wordlist to words that could appear.
The easy part is to delete hyphens and similar.
The hard part, however: Remove words containing more than seven letters.
So, the problem:
Given a set of words containing only lowercase (or uppercase) ASCII letters, remove the words containing eight or more different letters.
Any input and output format is acceptable.
[Standard loophole rules](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) apply.
Shortest byte count wins.
Clever solutions are better, and faster is better as well.
My solution (implementing a quite clever O(n) algorithm, noncompetitive ref implementation):
```
#include <stdio.h>
#include <stdint.h>
int main(void) {
char str[1024];
while(scanf("%s\n", str) == 1) {
uint32_t st = 0;
int s = 0;
for(char *p = str; *p && s <= 7; p++) {
s += ~st >> (*p - 'a') & 1;
st |= 1 << (*p - 'a');
}
if(s <= 7)
printf("%s\n", str);
}
}
```
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 11 bytes
```
{⍵/⍨8>≢∪⍵}¨
```
Takes input as a list of strings.
**Explanation:**
```
{⍵/⍨8>≢∪⍵}¨
{ ⍵}¨ for each word
∪ take unique letters
8>≢ length less than 8 as a boolean (0 or 1)
⍵/⍨ repeat word that many times
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///v/pR71b9R70rLOwedS561LEKyK09tOJ/2qO2CY96@x71TfX0f9TVfGi98aO2iUBecJAzkAzx8Az@n6agrqCu8ahzwaOutkddizTVSzJSi1MVEotSFYoz8otKFMrzi1KKFXLy89JBrJKMxBKgeGlOSl5@CVAgWyEpMQ8JqgMA "APL (Dyalog Unicode) – Try It Online")
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 20 bytes
```
*.grep(8>*.comb.Set)
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYKvwX0svvSi1QMPCTksvOT83SS84tUTzvzVXcWKlQppGdExdrIJSYlJySmpaekZmVnaOEliVJlyBUk5qSUlqUbGSjlJ@Xn5uYkl@QX5qZqJSrOZ/AA "Perl 6 – Try It Online")
Filters by words that have a set of letters with size less than 8.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 5 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
ʒÙg8‹
```
[Try it online.](https://tio.run/##NY@xbQMxDEVXMa72ANklcEHpaPkDPFEgdTHceQZ3HsW1u4yRRS6SLun@B8nH/9UpgLft@/F@po@f@2vbPifRNV5YbtPxMAncdeHM7t1GrbwUNbIxrUxFb2NyFqpX8kvXFLwic67dFEKugUTGGrmvC3IaZjZOCZ3NO8PUa0C7TYOukP58TxJJ1HBGpArNg1VMM89DwuQvose2Rl19tQRosXY4cjSe11bO/9sEBIEWTojdqrXfOwKrtVzT6Rc)
**Explanation:**
```
ʒ # Filter the (implicit) input-list by:
Ù # Only leave distinct letters of the word
g # Take its length
8‹ # And only leave those with a length smaller than 8
# (And output implicitly after we're done filtering)
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 6 bytes
```
Qṫ¥Ðḟ8
```
[Try it online!](https://tio.run/##Hc6xccMwDAXQHlN4jKyRMiVIwTRyEMEDKPs0QdpskCpV2hT2ubMn0SQMlBr4//13ElnHeN1uP4/v5@d2/XoZ2/338Pw4vI0huuQTyQrC7jpTJXfI2mluamgrdMKmq8NRsF/QT4DJO1eqHRpy7QlFHNB9mbkWh8moFN5rKEKm3hPHf4GuLLsQVkZR4yNn7KwVsJlWmgDZZOc9xxXhHAaHGj1cs9G0xFj/H5g4CWujwhnUAogMLxbsHw "Jelly – Try It Online")
### How it works
```
Qṫ¥Ðḟ8 Main link. Argument: A (array or words)
Ðḟ Filterfalse; only keep the words W of A for which the chain to the left
returns a falsy value.
¥ Combine the two links to the left into a dyadic chain.
Q Unique; remove duplicate letters from W.
ṫ 8 Tail 8; remove the first 7 letters of the result.
```
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf), 6 bytes
```
Ç{▀£7>
```
[Try it online!](https://tio.run/##LY/LUcQwDIbLyWXv3Ghkh4PsKI5mFMsjKTA7XPa2HdAAnUAnNBKkwO2Tpf/hDXxtwstxfD/efz7uX59Pz8dxnVj2uiLfpsvEZCYbdjSLqYrjNkRBc@cIQ275vjD4G9gaCMWcOnYPHkDdCzDnDZjtG/WWPCu2RmmKp1zFvFDoWtoKcWae@RVYlBaq4CQ9bYZKxzmJlP9qWY0bCHiNXIoupyv1qjjv8Rn7r1@oMMnARjUm0Yg81bRrlJlefgE "MathGolf – Try It Online")
## Explanation
Really similar to the 05AB1E solution, but I lose one byte thanks to explicitly having to define the code block for filtering.
```
Ç Implicit faulty filter by block
{ Start block
▀ Get unique characters of string
£ Get length
7> Is greater than 7
```
[Answer]
# J, 10 bytes
```
#~8>#@~.@>
```
# explanation
```
#~ 8 > #@~.@>
#~ NB. filter the input based on...
8 > NB. is 8 greater than...
#@ NB. the length of...
~.@ NB. the unique characters of...
> NB. the unboxed input.
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/less7JQd6vQc7P5rcqUmZ@QraKgnJiYmJSUlJyerW6snJxapayroWimkKaCIJyYlp6SmpWdkQtVA9Kqrw5QiSScWp6Ql5meU5xelFpRbJxbnJapzgcB/AA "J – Try It Online")
[Answer]
# Java 8, 46 bytes
```
s->s.filter(w->w.chars().distinct().count()<8)
```
[Try it online.](https://tio.run/##hVHBTsMwDL3zFVFPjaA5o21M4g677Ig4uGnWeaRxFaebJrRvH046EBIHLrEtO@89Px/gCM2h@7haD8zqFTB83imFIbm4A@vUJpdKHWTOTAm94RQdDGZbwkoChn6tbP3fBOulIF3u5OEECa3aqKCe1JWbNZsdemGsT836ZOweItfadMgJg02SWpqCxNWjvi4zwji1XhBuQEfCTg0ivZ7J3t4V6Fn39szJDYamZEZpJR9@CX2OEc5sEs3f6mDs3y7wi@ioK0@T3Tt/rh5U5ZGZBhcccy4tCcdIEWLpJgcjnUtn5yGdgPc5hzav40LKxShqUwvelzGxfhpEQSm66PoeM7abMSJxalH@9gWd0GfyWYkFTxF3aMUICgVrjBRcV1KM/iaRrYxBzo6iAEXWDC7@RtdNshx/b9OieEuj69HmkqJwzxA4iU2u0rcLy10GGGtq1nRfVVqLkcWznyssFsGdtL4d/nL9Ag)
**Explanation:**
```
s-> // Method with String-Stream as both parameter and return-type
s.filter(w-> // Filter the words in the input-Stream by:
w.chars() // Convert the String to characters
.distinct() // Only leave distinct characters
.count()<8) // Only leave words with less than 8 distinct characters
```
[Answer]
# [Python 2](https://docs.python.org/2/), 40 bytes
```
lambda i:[x for x in i if len(set(x))<8]
```
[Try it online!](https://tio.run/##HY8xcoUwDER7ncLzG6BJkSqTSU6Sn0I2MmhGWB7LJHB6IlJL@95uPfuq5fXKn89LcIszBn7/OkLWFo7AJXDgHITKaNTHY5o@3r6v2rj0kMdhGET3tJKcIGymGxUyg6SdtqoN2wmdsOppkAX7L9oKGK1zodKhomMiihig2b5xWQzmRsvCN4Y81NR6ZP9foCvLbXBXQtHGmRN21gJYmxaaAbnJrbfkV4Qfd7BbncMlNZp3L2v/BSNHYa20cAJtLvAM776KfNKLVeE@Pp7lMU3XHw "Python 2 – Try It Online")
Test cases borrowed from @Dennis. Input and output are both lists.
[Answer]
# [Red](http://www.red-lang.org), 54 bytes
```
func[b][foreach a b[if 8 > length? unique a[print a]]]
```
[Try it online!](https://tio.run/##PVK5jhsxDO31FYQ/YOtgi6RJulQBUhkuOBJnTEDXiuIeCPLtzpOdpBuI5DtnSLr9kHS@hP35tnuN5@1y3tsQjldi2s660yf6TFnqMa9fyKu@uBCf@9A6iS@Xy20@06/cPF4lf4SsZq1IFbMQ25TS2@DxEaZwbx8W9szzje0aeLOpVeoMnQG1cc4W2MyL1sNCGnIcumAER6PZ3BT7R5hN82IAV@Tchu4aeWqrgftoVVJgHXnRW8SUwys4FKzA0RqHJIdYuwvcdMvauhwaQxsgwI06nMnvEAy2viOJQtqhilIDG5nCdZFJsVWTOGX6IE7aFaf1IMlYMElYJ1G30hI9UiCwa9LkyM0nZd4ATkC6AwsVPioTZwTMT/RzklQtgCYEgg/YUC704mpUEcfwRPIuI@q82yfPmUtsD@C1pKaL6I6oHcskDNkFktpDPpjmE31dkOxTSIdDyMOoVhrSh1ylJhkwhYfXlr2DTqBm@VztUNSc/8UDP067H8qT6hJEndEBMnqib@9R@hRfGSKCFiMLmqPoXRPPdQEX6FATGiNbOYEzeu68bFPbUbUyJTEZa1paXip4xaNIw/6m6gX17WR9TQErbxmVhscvezr9Hxmd6HT7Aw "Red – Try It Online")
The first test set was taken from Dennis'
[Answer]
# JavaScript, 33 bytes
```
a=>a.filter(s=>new Set(s).size<8)
```
[Try it online](https://tio.run/##LY87bsMwDIavUniygdZzhjqX6Fh0oGVaYUGTAiknSC/vUm63jyL/h77hDp6MSn0TXfBYpwOmK4wrcUXrfboKPl4@sPY@jE4/@H4ZjqTiyjiy5n7tPzvWPd2Qn91rx@SuGwq6x5S04lbUwNquIhR9tveVoT7Ab4EweyVBqcEFSOoMzO0G3PeNJDdeDHOmZoqn3NTrTKHLzVaJW@aZn4DVaKUElVSaTTEVXBqR8V8tT3EDAffIpehyupIkw2WPz/h//ZlmJi2YKcWkFpGnmnaLMt3XMBy/), using Dennis' test cases
[Answer]
# [C# (.NET Core)](https://www.microsoft.com/net/learn/dotnet/what-is-dotnet), 58 bytes
```
a=>a.Where(x=>x.GroupBy(y=>y).Count()<8)
```
[Try It Online!](https://tio.run/##XVCxTsMwEJ3xV5w62VLJjJQmAxVUSCAhGDoghrNzaQyODbZTGlX59mCiFFCfPNy9e/d0fipcKudp7IK2O3juQ6Q2Z/@7bO2MIRW1syHbkCWv1ZniXtvPnCmDIcAjHBkkhIhRK9g7XcEDastFGkyTH9x2Vq1C9Mnk5XUJdze2a8mjNDSzZQkSoIARixKzbUOe@KEoD9nGu@7juud9UfYi3dbZyMXqSow5uzgZgkqblr5SdYQFSlVRvWv027szoWprt1gmdoacMDGhSm@qZJgbGPLfm@uUE6oG@B49oARtQXIlxPzhE9YpJ2co23odKSVDHKX4cxnYufCJsJp0s2pgw/gN)
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 104 95 bytes
Dennis's word set was also used here.
Thanks to nwellnhof for the suggestions.
```
char*s,*t;f(i,j,k){for(;~scanf("%ms",&s);i<8&&puts(s))for(i=j=0,t=s;*t;j=k)k=j|1<<*t++,i+=j<k;}
```
[Try it online!](https://tio.run/##Hc5RT4MwFAXg9/4KssSFbizRNxPgobCO3aRrSW/R7JFgmAW3mRX1Yc6fLhaf7znnu83q0DTj2LzWl4WLFkPchjbqop5e2/MljH9cU5/acHZ3dLNo7mhsk8f5/P1jcKGjdIrYtEvvoyF1sS93aU/7tPt@SJLFsFxGdpl2SR/fRnsagmNtT@Hn2b7Q4Bq0IY2D2yhUlW@52BMBiGrHJUckuTJ8VyrN9J4Yzkq1R7IRzDwz3BKWoQHJpSElA2kyJgQShljtQBZI1poXBUwz3Je0QpOBzxfEKBCT4K2cCaVhAzkzoCRhpVaSrwkDLSYec39l5Mkb4FW/AzLXfF35Z/H/wQwyAarkBeREaQ/4DlTas79N@1Yf3Lj6@gM "C (gcc) – Try It Online")
[Answer]
# perl -nlE, 32 bytes
```
my%h;@h{/./g}=();say if keys%h<8
```
This reads words from `STDIN`, printing out those with less than 7 different characters.
[Answer]
# [C++ (gcc)](https://gcc.gnu.org/), ~~105~~ 104 bytes
```
#import<bits/stdc++.h>
f(){for(char*n;~scanf("%ms",&n);)std::set<int>(n,n+strlen(n)).size()<8&&puts(n);}
```
[Try it online!](https://tio.run/##HY7LTsMwEEXXzFegIqqEPtiipqrkpG46kmtHtgPqMoSkjdS6URxYgODTCVO2M/eec8u2nR3KchjumnN76frla9P7R9@/lZPJ/LiCOgi/6ksXlMeie3DRjy8LVwej@7MfTccujEKKLha@6peN61eBm7qJ77tT5QIXhnPffFZBuHwaj9v33tMp@h4od3suGkdguCF8BN@DUHmy5WIPAo1ROy65MZAoy3eZ0kzvwXKWqb2BjWD2hZktsNhYlFxayBhKGzMhDDBj8h3K1MBa8zTFK4ZTSStjY6R8ClahuBrIlTChNG4wYRaVBJZpJfkaGGpx1ZuEvgyeyYFkJQ7KRPN1TmPN/8AYY4Eq4ykmoDQJqIO5Ju1vWZ@Kgx9mdVt158b75qP6Aw "C++ (gcc) – Try It Online")
-1 byte thanks to @ceilingcat
[Answer]
# [Racket](https://racket-lang.org/), 95 bytes
```
(require racket/set)(define(f l)(filter(lambda(x)(<(set-count(list->set(string->list x)))8))l))
```
[Try it online!](https://tio.run/##NVAxcsMwDNvzCp87VBpyXTv08hdKph1eadEl6TZ5fUq56QZQIABRoX6iP14Y2jLoQd4KGD6S4tdOiv9DQ89pwpkapnngnGZiR00Ma5kg3XL6SKE5V9mbJybz8yV4Mldqy/nSJ8Mt5/yeM@f8eHoNHOPXNLLs9Yp8H4cxlCYrNjQLVsVx3URB@5sjbHLv85nBf8CuAaGYh1XzwBtQ8wLMXQNm@xrpHU@Ky0LdFI91FfNCsbd0WyHumUd@BRalmSo4Ses2m0rDqSNS/qtlNTQQ4DtyKbocrtSq4rTHZ@xZv1Bhkg0XqsFEI/LYpl17mTHn0ylNZBvDfeiHNY/j/AI "Racket – Try It Online")
The test set was taken from Dennis'
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 12 bytes
```
ΦＡ›⁸ＬΦι⁼μ⌕ιλ
```
[Try it online!](https://tio.run/##NVAxbsMwDPyK4ckB3L1A56Yo0KF7kIGWGZsATaqklCKvdyW50XRHno5HhhUsKPC@fxtJGs7ECW34lJjTcBq7D0Oohdex@0JZ0vpU0Ni9/2RgH7axO5PMtcKn473t@@XSs@awIj/6seuZ3HVDQfdKg0rCLaqBtXZCiPporRtD@gVfK4bJEwlKqiRCCTgBc5OBe95IlkZmw2Whao6Hh6mnicrfpbkrcZ1@RAnAanSjAIlUmlc0FZwbJOP/jB6KDCq6lwRUYh3mJMFwzmU7f64z0cSkERcKlaqV2YcF5XJW7K/X/eXOfw "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
Ａ Input array
Φ Filter strings where
⁸ Literal 8
› Is greater than
Ｌ Length of
ι Current string
Φ Filtered on characters where
μ Inner index
⁼ Equals
λ Current character's
⌕ First index in
ι Current string
Implicitly print matching strings
```
[Answer]
# Japt `-f`, 6 bytes
```
¬â Ê<8
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.6&code=rOIgyjw4&input=WyJsb3VjaGVseSIsImxpc3NvbWVuZXNzIiwiY290ZW1wb3JhcnkiLCJ0ZWFwb3lzIiwiZmxhdHdhc2giLCJhYnN0aW5lbnQiLCJwYWludGJhbGxzIiwiYXNzdW1pbmdzIiwiZHJlZ2dpbmVzc2VzIiwiZnJvc3RiaXRpbmciLCJ0b2lsc29tZWx5IiwiY2Fsb3JpZmljYXRpb24iLCJhcHJvbmVkIiwiYWlybGVzcyIsInNjb3JpYSIsInZlbnRpbGF0ZXMiLCJpbmNyZWR1bG91c25lc3MiLCJiaWJsaW9wZWdpYyIsIm9yYml0Iiwic2NpdXJpbmUiXQotZg==), using Dennis' test cases
[Answer]
# JavaScript (ES6), 53 bytes
Without [using a set](https://codegolf.stackexchange.com/a/175590/58563):
```
a=>a.filter(w=>[...w].every(o=c=>o[c]=o[c]||--k,k=8))
```
[Try it online!](https://tio.run/##NZBBjoMwDEWvMmJFpcJ6NulFEAsTTOqpGyM7UFXq3ZkkzGyi/2Xn@ds/sIN5pTV1UWY8FneAu0G/ECfU9uVuQ9/3r7HHHfXdivPuJoMfXXk@n657XB/u@3I5vEQTxp4ltEs7NCybvyO/m@tXw2QmT4xoVqyXhM9VFLRWE8Iq71pZGNIL7F40TJYoYkzFrEAxTcBc28Bse1IM1cyKIVBh48lQsTRR/hsqXYjL8DOJBxalhTwkklhZq0rEuUpS/otoPrdBUXtOQDnWCafoFectL2f/20w0McmKgXyxonn2iaBNc65mzNf5BQ "JavaScript (Node.js) – Try It Online") (using Dennis' test set)
[Answer]
# Snap! 4, scratchblocks2 syntax
(pretending that Snap! exclusive blocks are valid in scratchblocks2 but functions use the Scratch `define`)
# 69 bytes
`b` takes a list of strings.
```
define((b)
report((#)keep items such that(<(length of [])<[7]>)from(b
```
] |
[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 8 years ago.
[Improve this question](/posts/61371/edit)
## **Energy levels of electrons**
Electrons are ordered into "shells". However, sometimes electrons get excited, for example by heat, and leave their shell to go to another! These electrons will go back at some point, but they cannot go back to their original shell without emitting energy in the form of radio waves.
For example, the energy levels for hydrogen look like this:
[](https://i.stack.imgur.com/Dgch8.gif)
The base energy level of an electron in hydrogen is at `n = 1`. If it gets 'excited', it might go to `n = 4`. However, on the way back, the electron does not always simply go from `n = 4` to `n = 1`, it has different options. See the example.
## **Task**
Write a program or function that takes an integer and outputs the amount of options the electron has to get back to its un-excited state. For this task, you can take granted that an electron can only emit energy from its excited state. It will not get more energy once it has been excited.
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), the answer with the least amount of bytes wins.
If you are interested in these type of questions, check out this similar [question](https://codegolf.stackexchange.com/questions/37657/electron-configurations). Also check out [this](http://hyperphysics.phy-astr.gsu.edu/hbase/hyde.html) for more info on these matters.
## **Input**
The input of your function/program is a whole integer. It is greater than `0` and less than 2^31.
## **Output**
An integer, the amount of options the electron has to return to its original state, which is `n = 1` (for hydrogen). When the input is 1, return 0, as it is already in its original energy level.
## **Examples**
```
Input: 4
Output: 4
```
Because the options are:
```
4 -> 3 -> 2 -> 1
4 -> 3 -> 1
4 -> 2 -> 1
4 -> 1
```
Visualised:
[](https://i.stack.imgur.com/DlF1K.gif)
[Answer]
# Pyth, 5 bytes
```
/^2Q4
```
I integer-divide by 4 instead of subtracting two from the power and flooring.
[Answer]
# CJam, ~~6~~ ~~8~~ 7 bytes
```
1li2-m<
```
[Try it online](http://cjam.aditsu.net/#code=1li2-m%3C&input=4)
Unless I completely misunderstood the question, the result is simply 2^(n-2). For each level between n and 1, you can either skip or not skip it on the way back.
Using the left shift operator instead of the power operator is one byte more, but gives the specified result 0 for n=1, while the power operator gives 0.5 for that case.
Explanation:
```
1 Push 1 for later shift operator.
li Get input and convert to int.
2- Subtract 2.
m< Left-shift 1 by (n-2).
```
If I shamelessly stole Thomas Kwa's approach, this would be 6 bytes in CJam:
```
2li#4/
```
[Answer]
# Dyalog APL, 6 bytes
```
⌊2*-∘2
```
This is a monadic function train. It is equivalent to the following, trainless function.
```
{⌊2*⍵-2}
```
Try it online on [TryAPL](http://tryapl.org/?a=%28%u230A2*-%u22182%29%204&run).
### How it works
```
-∘2 Take the right argument and subtract 2.
2* Elevate 2 to the difference.
⌊ Round down to the nearest integer.
```
[Answer]
# JavaScript ES7, ~~12~~ 11 bytes
```
i=>2**(i-2)
```
Defines an anonymous function.
[Answer]
## Python, ~~29~~ ~~22~~ 16 bytes
```
lambda n:2**n//4
```
Technique shamelessly stolen from [Thomas's answer](https://codegolf.stackexchange.com/a/61378/45941).
[Try it online](http://ideone.com/xIpYCC)
[Answer]
# Stuck, 6 bytes
```
2i2-^)
```
Hey look I ~~almost outgolfed Pyth~~ outgolfed CJam
[Answer]
# dc, 6
```
2?^4/p
```
Algorithm expertly lifted from other correct answers.
### Testcases:
```
$ for t in 1 4; do dc -e'2?^4/p' <<< $t; done
0
4
$
```
[Answer]
# Julia, 9 bytes
```
n->2^n÷4
```
Like several other answers, this uses [Thomas's approach](https://codegolf.stackexchange.com/a/61378/20469). `÷` performs integer division in Julia (but unfortunately is 2 bytes in UTF-8).
[Answer]
# PHP, 28 bytes
I hope I got it right. `floor` handles the case for `1` where it should output `0`
```
<?=floor(pow(2,$argv[1]-2));
```
Works from command line like:
```
electrons.php 4
```
+1 and thanks to [Reto Koradi](https://codegolf.stackexchange.com/a/61373/41859) for providing the formula. ;)
[Answer]
## [Minkolang 0.9](https://github.com/elendiastarman/Minkolang), 7 bytes
Copying [Thomas](https://codegolf.stackexchange.com/a/61378/12914) like everyone else...
```
2n;4:N.
```
This is a full program, and the first five characters are equivalent to `2**n//4` in Python 3. [Try it online.](http://play.starmaninnovations.com/minkolang/?code=2n%3B4%3AN.)
] |
[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/20478/edit)
Your task is to write a **function** that sorts an array.
---
Your **function**:
* Cannot call other functions (excluding itself, of course);
* Must receive an array of integers as input, and it must return the ordered array. Feel free to add other parameters as input, if you need them.
* Cannot use **any** kind of loop (for, while...) except recursion;
* Cannot access the internet;
* Can be overloaded if you need it.
---
Code-Golf here. Shortest code wins, as usual.
Happy coding!
[Answer]
## APL (36)
```
{⍵≡⍬:⍬⋄(∇z/m),p,∇m/⍨~z←(p←⊃⍵)≥m←1↓⍵}
```
It's quicksort:
* `⍵≡⍬`: if the list is equal to the empty list
* `:⍬`: then return the empty list
* `⋄`: otherwise:
+ `m←1↓⍵`: `m` is the list minus its first element
+ `p←⊃⍵`: `p` (pivot) is the first element
+ `z←(p←⊃⍵)≥m`: `z` is a bitmask of those values of `m` that are smaller than `p`.
+ `∇m/⍨~z` select the inverse of `z` from `m` (= larger numbers) , and sort it recursively
+ `p,`: pivot
+ `∇z/m`: select `z` from `m` (= smaller or equal numbers) and sort it recursively
[Answer]
## GolfScript (42 41)
```
{.,2={[.(+].~>=}*.,2>{(\S+)\S\+(\S+}*}:S;
```
Note: this assumes that `bool{...}*` is acceptable as an `if` without `else`. (Technically it's a loop). Replacing it with `bool{...}{}if` would add 3 chars twice.
This is a pessimisation of an already bad sorting algorithm presented in an exercise of *Introduction to Algorithms*, by Cormen, Leiserson, and Rivest. From memory, their version is
```
sort(A, off, len):
if (len == 2) special case.
if (len > 2):
third = floor(len / 3)
sort(A, off, len - third)
sort(A, off + third, len - third)
sort(A, off, len - third)
```
But all that mucking around with thirds uses characters. I do
```
sort(A, off, len):
if (len == 2) special case.
if (len > 2):
sort(A, off, len - 1)
sort(A, off + 1, len - 1)
sort(A, off, len - 1)
```
[Answer]
## Haskell - 51
Standard insertion sort in Haskell. I hoped I would beat golfscript for once but alas, I could not.
I could save two chars if I left out the [] from first line and require the user to pass an extra empty array as parameter, but since it makes no difference I opt not to do so.
Actually I'm not sure if foldr is allowed. It's a higher order function that sort of automates one family of recursion. If it's not drop a comment and I'll do my best to fix this.
```
s=foldr(%)[]
e%[]=[e]
e%(s:t)|e<s=e:s:t|e>=s=s:e%t
```
[Answer]
**C - 137 char (including whitespaces)**
```
int*s(int*a,z,x,c){if(c){if(a[c-1]>a[c]){int t=a[c];a[c]=a[c-1];a[c-1]=t;}if(c>=z-1)c=-1;s(a,z,x,c+1);}if(x<z&&!c)s(a,z,x+1,1);return a;}
```
expanded version
```
int* s(int *a,z,x,c) // this give a warning because of not specified type, but default is int so it's ok
{
if (c)
{
if (a[c-1] > a[c])
{
int t = a[c];
a[c] = a[c-1];
a[c-1] = t;
}
if (c >= z-1)
c = -1;
s(a, z, x, c+1);
}
if (x < z && !c)
s(a, z, x+1, 1);
return a;
}
```
If you want to test it add:
```
int anArray[10] = {10, 1, 123,121,34,12,43,65,86,34};
s(anArray, 10, 1, 1);
printArray(anArray);
void printArray(int *arr)
{
for(int i = 0; i < 10; i++) {
printf("%d ", arr[i]);
printf("\n");
}
printf("\n");
}
```
[Answer]
## Python 3 and 2 - ~~129~~ 125 bytes
```
def s(a,i,m,o,l):
if i<l:return s(a,i+1,[m,i][a[m]<a[i]],o,l)
if l-o:a[o],a[m]=a[m],a[o];return s(a,o+1,-1,o+1,l)
return a
```
This is called as `s(list,0,-1,0,list_length)`.
The `i<len(a)` part simply runs through the array, finding the index of the max value. Then, we swap the value at that index with the current index (which I decided to call offset (`o`)).
This works even for an empty list and a one element list.
Note:Since it wasn't specified, I sorted descending. If the order should be ascending, replace the `<` at `a[m]<a[i]` with `>`.
[Answer]
### GolfScript, 47 46 characters
```
{.,1>{.,3<{.~>{[~\]}*}{(\S(@[\]S~@+S+}if}*}:S;
```
The code became quite long in the end without using all those useful operators. You can try it [online](http://golfscript.apphb.com/?c=ey4sMT57LiwzPHsufj57W35cXX0qfXsoXFMoQFtcXVN%2BQCtTK31pZn0qfTpTOwoKWzYgNCAwIDggMyA5IDUgMSAyIDddIFMK&run=true).
```
{
.,1>{ # if length(array)>1
.,3<{ # if length(array)<3
.~> # copy array, expand and compare
{ # if two elements have wrong order
[~\] # swap
}* # end if
}{ # else (recursive sort)
(\S # remove first element, recursively sort rest of array
(@ # take first element and first element (smallest) of rest of array
[\]S # sort those two
~ # take smaller one
@+S # concat other with rest of array and sort again
+ # join results
}if # end if
}*
}:S;
```
[Answer]
## Ruby - 69 characters
```
f=->(a){a[1]?(b,c=a.shift,f.(a);b>c[0]?[c.shift]+f.([b]+c):[b]+c):a}
```
Explanation:
```
f=->(a){
a[1]? # if array length is larger than 1
(
b,c=a.shift,f.(a); # recurse on the tail of the array
b>c[0]? # compare the head with the first item in the sorted array
[c.shift]+f.([b]+c) # bigger - sort the array with the original head and concat with its own head
:[b]+c # add the head back to the sorted array
)
:a # array with 1 item or less - returns itself
}
```
[Answer]
**Javascript - 147 characters**
```
function s(a,i,j,l){(!l)&&(i=0,j=1,l=a.length);if(i<l){(n=a[i],m=a[j],1)&&(m<n)&&(a[i]=m,a[j]=n);return (j<l)?s(a,i,j+1,l):s(a,i+1,i+2,l)}return a}
```
Expanded:
```
function s(a,i,j,l) {
(!l) && (i=0,j=1,l=a.length)
if(i<l) {
if(j<l) {
if(a[j] < a[i]) {
var t = a[i];
a[i] = a[j];
a[j] = t;
}
return s(a,i,j+1,l);
}
return s(a,i+1,i+2,l);
}
return a;
}
```
[Answer]
# Python (78)
**Edit:**
```
def s(a,b,i):d=a[:1]>b[i:];b[i:i]=a[:d];return a and s(a[d:],b,[i+1,0][d])or b
```
Golfed into a one-liner by replacing `if` clause with Boolean `d` and actions that do nothing unless `d` is 1. Now sorts descending.
Also, used list slicing and comparisons to shorten the condition, taking advantage of the empty list being smaller than nonempty ones.
I'm still hoping for a shorter way to do `[i+1,0][d]`. One can do equal with `i+=1;i-i*d`. Operator precedence is annoying here. I'd like to do something like `(i+1)*!d`, where `!` is some higher-precedence way to complement `d`. Unfortunately, `1^d` is too low-precedence.
---
Old version: (108 chars)
```
def s(a,b,i):
if not a:return b
if b[i:]and a[0]>b[i]:i+=1
else:b[i:i]=a[:1];a=a[1:];i=0
return s(a,b,i)
```
Call this as `s(a,[],0)`, where `a` is the list to sort. In the recursion, `a` is the remaining list to sort and `b` is the part that's been sorted so far. Elements from `a` are pushed into `b`, which is maintained sorted. The index `i` tracks where we're looking to put the current element of `a`.
The line `if not a:return b` is horrendously wasteful. I'll try to golf it into something better when I get a chance.
[Answer]
# C, 114, characters
```
int*f(int*a,int s,int i){int*c=a+i,*d=c+1;return s>1?*c>*d&&(*c^=*d,*d^=*c,*c^=*d),i+2<s?f(a,s,i+1):f(a,s-1,0):a;}
```
ungolfed:
```
int*f(int*a,int s,int i){
int*c=a+i,*d=c+1;
return s>1
? *c>*d
&&(*c^=*d,*d^=*c,*c^=*d), //xor-swap
i+2<s
?f(a,s,i+1) // swap the biggest number to the end of the array
:f(a,s-1,0) // last element of array is the biggest & sorted
:a;
}
```
**Explaination**
This solution uses a bubble-sort. The result of every iteration of the bubble sort is that the largest element is at the end of the array, so we don't need to sort that part anymore and reduce the size of the array after every iteration. The algorithm is finished if we get to sort an array of the length 1.
Instead of swapping using a temporary variable I'm using a xor-swap. This only works on integers.
**Further Golfing:**
I have to write `int` a lot and it wastes a lot of characters, but I can't remove these like seen in the other C solution by @LombaX, because GCC throws an error if I do.
An other thing I could do which may result in a shorter code size is using a `int*` parameter as output instead of the return variable. The memory for the `int*` output parameter could be provided by the user of the function. In this solution I wouldn't have to swap and there would probably be a better algorithm.
[Answer]
## C 142 bytes
Golfed
```
void s(int *a, int i,int j,int n)
{if((i+1)>=n)return;int t=0;if(a[i]>a[j]){t=a[i];a[i]=a[j];a[j]=t;}j++;
if((j+1)>=n){j=i+1;i++;}s(a,i,j,n);}
```
Ungolfed source: sorts in ascending order by swapping elements using i,j as indices.
```
void rec_sort(int *a, int i,int j,int n)
{
if((i+1)>=n) return;
int t=0;
if(a[i]>a[j])
{
t=a[i];
a[i]=a[j];
a[j]=t;
}
j++;
if((j+1)>=n)
{
j=i+1;
i++;
}
rec_sort(a, i, j, n);
}
```
[Answer]
# Python 2: 116
A simple bubble sort implementation
```
def s(l,i,d):
n=i+1
if n==len(l):return l if d else s(l,0,1)
if l[i]>l[n]:l[i:i+2]=l[n],l[i];d=0
return s(l,n,d)
```
] |
[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 7 years ago.
[Improve this question](/posts/4093/edit)
Every number of the form 2i (where `i` is a non-negative integer) has a single 1 in its binary representation. Given such a number, output the 1-based position of the 1.
Examples:
```
DECIMAL BINARY POSITION
--------------------------
1 0001 1
2 0010 2
4 0100 3
8 1000 4
N 0...1...0 ?
```
[Answer]
Stolen wholesale from [Bit twiddling hacks](http://graphics.stanford.edu/~seander/bithacks.html#IntegerLogDeBruijn):
```
uint8_t f(uint32_t v)
{
static const uint8_t MultiplyDeBruijnBitPosition2[32] = {
0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8,
31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10, 9
};
return MultiplyDeBruijnBitPosition2[(uint32_t)(v * 0x077CB531U) >> 27];
}
```
[Answer]
# R, 14 or 22 characters
```
p=function(x)log2(x)+1
```
It remains fully vectorized, so not only can you do it for one number you can do it for any vector of numbers:
```
> n <- 2^seq(0,10)
> n
[1] 1 2 4 8 16 32 64 128 256 512 1024
> p(n)
[1] 1 2 3 4 5 6 7 8 9 10 11
```
Doesn't seem terribly slow either:
```
Unit: microseconds
expr min lq median uq max
1 p(16) 4.749 4.749 4.75 5.029 33.524
```
As an expression, it can be cut down to 14 characters: `log2(scan())+1`
```
> log2(scan())+1
1: 1
2: 2
3: 4
4: 8
5: 16
6:
Read 5 items
[1] 1 2 3 4 5
```
[Answer]
**GNU C, POSIX C, or MSVC: usually 2 instructions with low latency (see below for perf)**
You can do the same thing even more portably with Rust, where [`foo.trailing_zeros()`](https://doc.rust-lang.org/std/primitive.i32.html#method.trailing_zeros) is a language built-in for all integer primitive types.
Performance varies a lot with hardware, but this inlines to whatever the hardware is capable of. This works on any architecture that has a GNU or POSIX compiler.
Most CPU architectures can count leading zeros or trailing zeros in one instruction. (See [Wikipedia's Find First Set article](https://en.wikipedia.org/wiki/Find_first_set)). We can use either, since there's only one set bit. Knowing that our input is always non-zero also simplifies things. (Especially for x86 where BSF and BSR leave their output undefined when the input is zero).
The trick is to write something that will compile to that for the target architecture. Since pure C unfortunately doesn't provide a portable way to express this, we use macros to detect language extensions.
```
#define _GNU_SOURCE // request that string.h define ffsl
#include <stdint.h>
#include <stdlib.h>
#ifdef __unix__
// https://stackoverflow.com/questions/11350878/how-can-i-determine-if-the-operating-system-is-posix-in-c
#include <unistd.h> // for _POSIX_VERSION
#endif
#ifdef _POSIX_VERSION
#include <strings.h>
#include <string.h> // for GNU-extension ffsl in case we want that
int bit_position_posix(uint32_t v) {
#ifdef __GNUC__
// tell the compiler about the assumption that v!=0
// unfortunately doesn't help gcc or clang make better ffs() code :( And ICC makes worse code
if (v == 0)
__builtin_unreachable();
#endif
return ffs(v);
}
#endif
#ifdef __GNUC__
int bit_position_gnu(uint32_t v) {
// v is guaranteed to be non-zero, so we can use a function that's undefined in that case
// we can count from the front or back, since there's only one bit set
// but the compiler doesn't know this so we use macros to select a method that doesn't e.g. require an RBIT instruction on ARM
// TODO: tweak this for more architectures
#if (defined(__i386__) || defined(__x86_64__))
return __builtin_ctz(v) + 1;
#else
return 32 - __builtin_clz(v) + 1;
#endif
}
#endif
#ifdef _MSC_VER
// https://msdn.microsoft.com/en-us/library/wfd9z0bb.aspx
#include <intrin.h>
int bit_position_msvc(uint32_t v) {
unsigned long idx;
int nonzero = _BitScanForward(&idx, v);
return idx + 1;
}
#endif
static inline
int bit_position(uint32_t v)
{
#ifdef __GNUC__
return bit_position_gnu(v);
#elif defined(_MSC_VER)
return bit_position_msvc(v);
#elif defined(_POSIX_VERSION)
return bit_position_posix(v);
#else
#error no good bitscan detected for this platform
#endif
}
```
sample asm output **[from the Godbolt compiler explorer](https://godbolt.org/z/GWhvfd1eP)**:
```
# gcc6.2 for x86-64 -O3
bit_position_gnu:
xor eax, eax # break BSF/TZCNT's false dependency on destination
rep bsf eax, edi # 3 cycle latency # runs as BSF on CPUs that don't support TZCNT
add eax, 1 # 1 cycle latency
ret
#MSVC: same thing but without the xor-zeroing
# yes, beta Godbolt has cl.exe installed
bit_position_msvc PROC
bsf eax, ecx
inc eax
ret 0
bit_position_msvc ENDP
```
Using count leading vs. count trailing zeros shouldn't hurt the code on x86, but it does. With count-leading, gcc doesn't fold the `33-...` part into the `32-bsr()` that it does as part of implementing the builtin (since BSR produces the bit-index of the high bit, rather than counting leading zeros). See comments on [this question and my answer there](https://stackoverflow.com/questions/40431599/efficiently-dividing-unsigned-value-by-a-power-of-two-rounding-up) for more discussion about using `reg_width - __builtin_clzl` vs. using `__builtin_ctz` on power-of-2 integer.
---
**Perf analysis**: ([see Agner Fog's instruction tables and microarch pdf](http://agner.org/optimize/), and [the SO x86 tag wiki](https://stackoverflow.com/tags/x86/info)).
ADD is always 1c latency on all x86 CPUs worth mentioning. On Intel Core2, BSF is 2c latency with one per clock throughput. On Nehalem and later (up to Skylake at least), it's 3 cycle latency.
BSF is slow on Atom (16c) and Silvermont (10c), and on P4 Prescott (16c). Some of the pure-C sequences may be faster on those CPUs, since gcc still uses BSF even with `-march=atom` (which implies `-mtune=atom`).
BSF is fairly slow on all AMD CPUs, but TZCNT is fast (2c latency). This is why gcc uses `rep bsf` (which will decode as TZCNT on CPUs which support it, but as just plain BSF on CPUs which don't, ignoring prefixes which don't apply). So on AMD Piledriver and later, this sequence has 3c total latency. But on AMD Bulldozer (which only has LZCNT, not TZCNT), we should have used `32 - lzcnt(v) + 1` (but BSR vs. LZCNT produce different results even for non-zero inputs, so that binary would only be usable on CPUs that support LZCNT).
This is not limited to x86, either:
```
bit_position_gnu: # ARM gcc5.4 -O3 -mcpu=cortex-a53
clz r0, r0
rsb r0, r0, #33
bx lr
bit_position_gnu: # ARM64 gcc5.4 -O3
mov w1, 33
clz w0, w0
sub w0, w1, w0
ret
```
Performance: 2 cycle total latency from `clz` and `sub`. [This implies](http://www.sciencezero.org/index.php?title=ARM:_Count_leading_zeros) CLZ is always single-cycle on CPUs that support it (ARMv5T and later). I also found info for ARM9E-S specifically that `clz` is single cycle, in [my first google hit for `arm clz cycles`](https://developer.arm.com/documentation/ddi0165/b/I1028171).
Reverse-subtract with an immediate, and regular sub with a register, are both almost certainly single-cycle latency. (The mov of the constant in AArch64 is off the critical path, but for in-order CPUs is farther from being free.)
---
When an architecture doesn't have a bit-scan instruction that gcc knows how to use, it emits a call to a library function. e.g.
```
# gcc5.4 for MIPS el with -O3. Maybe there's an option to enable using clz if it's not baseline?
bit_position_gnu:
lui $28,%hi(__gnu_local_gp)
addiu $sp,$sp,-32
addiu $28,$28,%lo(__gnu_local_gp)
sw $31,28($sp)
lw $25,%call16(__clzsi2)($28) ## function address of __clzsi2
jalr $25
nop
li $3,33 # 0x21
lw $31,28($sp)
addiu $sp,$sp,32
j $31
subu $2,$3,$2
```
---
I don't have any compilers that support POSIX but not GNU, so I was only able to see if / how the `ffs()` version compiled by making it non-inline. It basically sucks because it accounts for the input=0 case even though we know that can't happen.
---
Related: [an SO C++ question](https://stackoverflow.com/questions/757059/position-of-least-significant-bit-that-is-set), but that doesn't have the simplifying factor that only a single bit is set.
[Answer]
# J - 4 characters
```
2&^.
```
Test:
```
i=: 2^ i. 10
2&^. i
0 1 2 3 4 5 6 7 8 9
```
[Answer]
## Haskell 65 characters
```
import List
main=n<-readLn;print$findIndices(>n)[2^n|n<-[0..]]!!0
```
[Answer]
If you like to make performance tests, I guess you need really big values for 2^i, so I use BigInt:
```
@annotation.tailrec
def binexp (n: BigInt, sofar: Int = 0): BigInt =
if (n < 2) 1 + sofar else binexp (n/2, sofar + 1)
```
The annotation is only to check, whether the compiler can perform a tailcall optimization.
I'm curios how you measure this challenge.
[Answer]
**Python, 38 bytes**
```
import math
print int(math.log(input(),2)+1)
```
[Answer]
# Ruby 20
No input or output is necessary because N is given and the question asks for "code":
```
Math::log2(N).to_i+1
```
[Answer]
# K, 8
```
1+&|0b\:
```
.
```
k)(1+&|0b\:)'(2*)\[10;1]
1
2
3
4
5
6
7
8
9
10
11
```
[Answer]
# Mathematica
I was surprised to find that Method #2 is much faster than Method #1.
**Some data**
```
t = Table[2^k, {k, 0, 10^5}];
```
**Method #1 Log base 2**
```
Log[2, t]; // AbsoluteTiming
```
>
> {0.203758, Null}
>
>
>
---
**Method 2: where is the 1 bit?**
```
Length[IntegerDigits[#, 2]] & t; // AbsoluteTiming
```
Break up the base 2 representation of the number into bits.
Find how many bits there are. (The 1 will always be farthest left.)
>
> {0.100730, Null}
>
>
>
[Answer]
## Python, 39 chars
```
f=lambda n:len(bin(n))-bin(n).find('1')
```
[Answer]
# JavaScript (ES6), 19 17 bytes
```
a=>Math.log2(a)+1
```
[Answer]
```
n = n - 1; //n is the input no.
count = 0; //count of set bits
while(n = (n & (n-1)))
count++;
return count + 1;
```
] |
[Question]
[
Okay, so I saw this in a meme and decided it'd be the perfect code golf challenge:
I prefer to increase the side of my indents according to the Fibonacci sequence:
```
class Kls
def method
t = Time.now
if t.hour >= 12
puts "It's afternoon"
if t.hour == 18
puts "It's time for your meal of:"
%w(bread sausage brocolli milk).each do |food|
"Some #{food}"
end
end
else
puts "It's not afternoon"
end
end
end
```
This means each line is indented by the sum of the spaces indented in the previous indentation-level. The first indention-level is indented by one space, then subsequent indention-levels are indented by 1, 2, 3, 5, 8, 13, 21, etc ***additional*** spaces.
## The challenge
Given a multi-line string with multiples of 2 spaces as indentation, convert it to a Fibonacci indented multi-line string instead.
This means every line with 0 indented spaces will remain 0 spaces; every line with 2 indented spaces will become 1 instead (sum of the first two Fibonacci numbers `0+1 = 1`); every line with 4 indented spaces will becomes 2 instead (sum of the first three Fibonacci numbers `0+1+1 = 2`); etc. So the number of indentations can be calculated as follows:
* Get the current amount of leading spaces (guaranteed to be a multiple of 2, so `[0,2,4,6,8,...]`)
* Divide this by 2, so we have our 0-indexed numbers (let's call it `n`)
* Get the first `[0,n]` (0-indexed) Fibonacci numbers
* Sum that sub-sequence together, and use that amount of leading spaces instead in the output
For example, for the output above, the input would have been:
```
class Kls
def method
t = Time.now
if t.hour >= 12
puts "It's afternoon"
if t.hour == 18
puts "It's time for your meal of:"
%w(bread sausage brocolli milk).each do |food|
"Some #{food}"
end
end
else
puts "It's not afternoon"
end
end
end
```
If we take a look at the line containing `"Some #{food}"`:
In the input it has 10 amount of leading spaces, so `n` will be `10/2 = 5`. The first `[0,5]` Fibonacci numbers are: `[0,1,1,2,3,5]`. When we take the sum of that list (`0+1+1+2+3+5`) the new amount of leading spaces in the output would be 12.
The amount of indented spaces in the output for every 2 indented spaces in the input will be `[0, 1, 2, 4, 7, 12, 20, 33, 54, 88, ...]` [A000071 on oeis.org](http://oeis.org/A000071) (except for the first 0).
## Challenge rules:
* The space-indentation of the input is guaranteed to be multiples of 2 (`[0,2,4,6,8,...]`)
* The input is guaranteed to not contain more than 1 consecutive space elsewhere (except for the leading indentation of course)
* Use whatever language you like
* Please include a link to an online interpreter
* Input should be a multi-line string (so no, string-lists/arrays aren't allowed)
* Output should also be a multi-line string (either printed or returned as string)
* Your method should work for deeper-indented Fibonacci indented multi-line strings than the example
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so try to do it in the fewest bytes possible.
## Additional test cases:
Input:
```
this
is
one
of
the
tests
!
```
Output:
```
this
is
one
of
the
tests
!
```
Input:
```
And
how
about
this ?
```
Output:
```
And
how
about
this ?
```
Input:
```
20 spaces?
```
Output:
```
20 spaces?
```
[Answer]
# [05AB1E (legacy)](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~22~~ 21 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
|εDgsðÛ©g-;LÅfOð*®J}»
```
[Try it online.](https://tio.run/##ZY/PSsNAEMbveYqPiPgHDFYQRIknL/4BD/oCm@xsEtzsyO6GIqZHn8In8CK9ePKW3H2ldFtLS9vLx8w332@GOT0X2YiGof37uSlcP@0/u6/i5Oqh/1CP/fS4@76bdL/DkGvhHO61iwBJCjX5kmVoAI8Uz1VNieHxwqgUfFJyY3GdYnS28IDXxjvEt/7AQShP1jCbeDlbE2kgLpbuBuPDBSi2eJvHahIarC7jVXR/fJhZEhJONE4UhMxyzlpXqCv9cpSQyEtIRquYZbvCgPiJw@a997k/We8jI6PNirSj3V8M@@1//oGgiILMAA)
**21 bytes alternative using the formula \$Fib(\frac{n}{2}+2)-1\$ instead of \$\sum\_{i=1}^{i=\frac{n}{2}}{Fib(i)}\$ :**
(Credit to [*@JonathanAllan*'s Jelly answer](https://codegolf.stackexchange.com/a/171059/52210) for this formula.)
```
|εDgsðÛ©g-;ÌÅf<ð*®J}»
```
[Try it online.](https://tio.run/##ZY89TsNAEIV7n@LJCPEjYREkJASYigYo4QJr76xtZe1Bu2tFCKek4wacgAaloaLz9lzJ2YQoUULzNPPmfTOa03ORjWgYut/v28L6mf/oP4uTK//u39S1nx33X/fT/mcYci2sxYO2ESBJoSZXsgwN4JDiqaopaXiyNCoFl5TcGtykGJ0tPeC5dRbxnTuwEMqRaZibeDXbEGkgLlbuFuPCBSg2eFnEahIarC7jdXR/cpgZEhJWtFYUhMxwzlpXqCs9PkpI5CUko1PMsltjQPzIYfPe68KfbvZRI6PtirSl/7807Hb/@QOCIgoyBw)
**Explanation:**
```
| # Take the input split by newlines
ε } # Map each line to:
Dg # Duplicate the line and take its length
s # Swap so the duplicated line is at the top of the stack again
ðÛ # Remove all leading spaces
© # Store the result in the register (without popping)
g # Take its length as well
- # Subtract both lengths from each other
; # Halve it, because they are multiples of 2 indented spaces
L # Create a list in the range [1, n]
Åf # Get the i'th Fibonacci number for each
O # And sum them together
ð* # Have that many space characters
®J # And join them with the saved string from the register
» # And finally print the mapped list with new-lines
```
[Answer]
# [Python 2](https://docs.python.org/2/), ~~111~~ ~~109~~ ~~100~~ 95 bytes
```
g=lambda n:n<1or g(n-2)+g(n-4)
def f(I):
for l in I:L=l.lstrip();print~-g(len(l)-len(L))*' '+L
```
[Try it online!](https://tio.run/##ZVDLTsMwELznK0ZGKDZVI7XigALhXtEbHLm4tZ1aON7IdlVVFH49OKVqVbjsY3ZnVrP9Pm3Iz4ehbZzsVkrC1/5pRgEt99O5mIzpXhRKGxi@EHUBk4cO1mNRLxtXuZiC7bl47IP16Xvacqc9d2I6pqUQdyXKyXIwnDG2djJGvLhYAKNip/N1lRsgocGb7XTlaXcErEGqNrQNeG4wmx8xoN@mCLZIZYQ0SQdP5NlpdmE0mfFwQq84KV84GtiPa52WDmRqdl693fFV0FIhym2UrcYq0Jqcs@is@xCVlusNFOFgiNThTAPYK2Xlm88R/7roaa@K60q7qP978ZT@@vkl5Igih/y8KvbOJl6@@1KI4Qc "Python 2 – Try It Online")
---
Saved:
* -5 bytes, thanks to ovs.
[Answer]
# [Husk](https://github.com/barbuz/Husk), 23 bytes
```
mȯF+M(R' !∫Θİf→½L)↕=' ¶
```
[Try it online!](https://tio.run/##bY@xSgNBEIb7PMVvRC5BONBKhLMMiNqoZZrN7ax3ZHdHdvcIYmyDtSD4DhZa2dkECysf4l7k3IshGmIxw8w/8/3DFJUfN435fBnsnvXOE2zV989fTx@vqp49zN9P@/XsMUswf2uaJtfCe5xo3wEkKRgKBcvYAAEZLktDqeXJQigVQlpw5XCUYW9/oQHXVfAYdo9D4iFUIGeZ7bC7nP4yWWQOluo6FeIRKHa4afcMCQ1WhysLYGfSGzkSEl5UXlwRRo5z1rqEKfW4n5LIC0jGVDHL6QpDPHDB0Xv7th3c/XEkKzvrFWlP/3xkOWx89YO0OcY3 "Husk – Try It Online")
### Explanation
```
m(F+M(R' !∫Θİf→½L)↕=' )¶ -- full program
¶ -- lines
m( ) -- map
↕=' -- | split on first non-space
M( ) -- | with the spaces
L -- | | length
½ -- | | halve
→ -- | | increment
İf -- | | Fibonacci numbers: [1,1,2,3,5..]
Θ -- | | prepend 0: [0,1,1,2,3,5..]
∫ -- | | cumulative sums: [0,1,2,4,7,12..]
! -- | | 1-based index
R' -- | | replicate that many spaces
F+ -- | join
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 20 bytes
```
Ỵµ=⁶i0‘H‘ÆḞ’⁶ẋ;t⁶$)Y
```
[Try it online!](https://tio.run/##ZY@/TsMwEIf3PMVPAUS7RMCEQGEGMcLC6MZnYnB8KHZUVRSpLCy8ACw8BSAEGzxJ8iLG/aNWhcFn33f3nXVXZMwohPbr9fst7@7f9U43eTqO5@eh/XjpJs@RtZ@Phz7em/2LEEJhhHM4NS4BJClU5EuWMQE8cpzrijLLwxnQCj4rualxlGN3b8aAm8Y7pCd@20EoT7VltumitjLyaOwv6Jrj4w9QXGM0batIGLA6SJetW8PeoCYh4UTjxCVhUHPBxmhU2lz3MxJFCckYK2Y5XmpAesZx8sbtlN@t5pGVyfqLjKP/u1j2f/eZCzEiieEX "Jelly – Try It Online")
---
# Explanation
Let \$x\$ be the 1-indexing index of the first non-whitespace character (\$1,3,5,7,\dots\$).
Then the new indent is
$$F\_{(x+1)/2+1}-1$$
where \$F\$ is the Fibonacci function.
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 37 bytes
```
m`^
+`( + )( +)
$2$1$1
*
```
[Try it online!](https://tio.run/##ZY9BT8MwDIXPza94KkVbmVSpOyGk7o44whktaxwakcQoSTUhxm8v6Zg2DS5P9rO/ZzlQMl5Ok9u@ChQoxGq7xKqos9QFIKp11VbtPLorxDT1VsaIJxsFoEjDURpY5QZI6PBiHDWe90fDaKRm4DFg06FdHz3gY0wR5WNaREidKHhmX55mF6LLxP3JvWJSvgDNAZ/zmiNpwfqhPK/e7pe7QFIhyjHKN8IucM/WGjhj3@uGZD9AMQ6aWR3OGFA@c06@@Zr970seeSWuK7KR/v/iOf395xfICpHlBw "Retina 0.8.2 – Try It Online") Warning: Lots of white space. Explanation:
```
m`^
```
Prefix each line with space tab space tab. These keep track of the previous and current Fibonacci number.
```
+`( + )( +)
$2$1$1
```
For each two spaces of the original indentation, compute the next Fibonacci number by summing the previous two.
```
*
```
Subtract 1 from the result and delete the previous Fibonacci number.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 17 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
Ỵµwt©⁶$HÆḞ€⁶ẋ;®)Y
```
A full program which prints the result.
**[Try it online!](https://tio.run/##ZY@xTsMwEIb3PMWvAIIukWBCoDCDGGFhdOMzCTg@ZDuKKsoAAwvvwI6EmAAh2MKTpC9i3FK1Kiynu//@7z/dBWk9CqH/eu3eWt89TW7f1w@/7/uPx8ndcxz6z4f97mVwFkIotHAOx9olgCSFmnzJMg6AR47TqqbMcDsTKgWfldxYHOTY3plpwFXjHdIjv@kglCdrmE063y2JPBK7c3WF8fECFFuMpraahAarvXRh3Wi3hpaEhBONE@eEoeWCta5QV/pykJEoSkjGWDHL8QID0hOOyWvXU/1mmUdGJqsdaUf/fzHs//7zC8SKJJYf "Jelly – Try It Online")**
### How?
The indentations required for a line of the output is \$Fib(\frac{s}{2}+2)-1\$ where \$s\$ is the number of spaces in the line of the input, and:
$$Fib(\frac{s}{2}+2)-1=\sum\_{i=1}^{i=\frac{s}{2}}{Fib(i)}$$
(\$i\$ could also start at \$0\$ since \$Fib(0)=0\$)
```
Ỵµwt©⁶$HÆḞ€⁶ẋ;®)Y - Main Link: list of characters
Ỵ - split at newlines
µ ) - for each line:
$ - last 2 links as a monad:
⁶ - literal space character
t - trim from both sides
© - (copy to register)
w - first index of that substring in the line
H - halve (this is (s+1)/2)
ÆḞ€ - Fibonacci of €ach (using an implicit range [1,2,...,s/2]
- where the (s+1)/2 is floored to s/2)
⁶ - literal space character
ẋ - repeat (vectorises) (e.g. [1,1,2,3,5] -> [[' '],[' '],[' ',' '],[' ',' ',' '],[' ',' ',' ',' ',' ']]
® - recall from register
; - concatenate
Y - join with newline characters
- implicit print
- ...smashes, so e.g. [[' '],[' '],[' ',' '],['x']] is just " x"
```
[Answer]
# Java 11, 150 bytes
```
s->{for(var l:s.split("\n"))System.out.println(" ".repeat(f(l.length()-(l=l.stripLeading()).length())-1)+l);};int f(int n){return n<1?1:f(n-2)+f(n-4);}
```
[Try it online](https://tio.run/##pVRdT9swFH3frzjLNGGLNlC0h4muoD1sEvtgD/BGmeQmDjE4dhU7IFT627vrOKGp1j0tD3Z8z/06J765F49ifJ8/bDItnMNPoczqDaCMl3UhMonLcAQercqRsStfK3MHx6dkXb@h5RIGM2zc@GxV2Jo9ihr61KVuqZVnydwknF89Oy@r1DY@XVK414bVcikF4UhGBdOplubOl4yPmZ45KrH8IUVOhb4wzfkryscTfqj5dD2lJChYWA1f1dI3tYH5NDmfnBbMjE/4Ydg@kOeGOlw2C60yOC88bS2Rimh2XG5uIXjk6KWjlqIQ37WbGyCXBSrpS5uHE7kQ12tVydTYp2hRBXxa2qbG2QyTk2gMRb3DPLnwBw6iIDGNtWae9PA2akZRH3vzbpynQiBR8RwcKyk0bHG6TQK8f2KLmqSCE40TdxKL2mZWa4VK6QeeSpGVyC1eCmvzl20cqMSVpezvVgFZD3NKk/eH11epndzHzFj/N7suqt1oQdJell5eX6pW2bgC1rxmtsW2C1/KYbsh1g0NwNvdvNH4OdYu@68zeMSCLuCwgHI435dj9zk5hlvSILjOt730w7vUhnZzoQyp090mI5/acWI8NWnGIjQNSAvvGYpk/K9nUProCN9oZjGZkITmwJOAuL74hWfpR3A28pJVowU1hthXOpwpxiEcdqcsunFK3w/4HjgYO27dyJEhpUnWJM9XVQcFf@MwGSX/2273dyBV2l67YwRHwbptdAcLDQUcorKN8bvNhu8R3Vh4zUpR30S/W96zoB/WcTIKPCOB9eYP) (NOTE: Both `String.repeat(int)` and `String.stripLeading()` are emulated as `repeat(String,int)` and `stripLeadingE(String)` respectively, because Java 11 isn't on TIO yet.)
**Explanation:**
```
s->{ // Method with String parameter and no return-type
for(var l:s.split("\n"))
// Loop over the lines of the input:
System.out.println(// Print with trailing new-line:
" ".repeat( // Repeat a space this many times:
f( // Call the separated (recursive) method `f` with the parameter:
l.length()// The length of the line,
-(l=l.stripLeading()).length()
// minus the length of the line without leading spaces
)-1 // minus 1
)+l);}; // And append the line without leading spaces
int f(int n){ // Separated method with integer as both parameter and return-type
return n<1? // If the input is 0 or lower:
1 // Return 1
: // Else:
f(n-2)+f(n-4);}
// Return a recursive call to `n-2` plus a recursive call to `n-4`
```
[Answer]
# Japt v2.0a0, ~~20~~ 19 bytes
```
r/^ +/m@ÓMgXÊz ÄÄ)ç
```
[Try it](https://ethproductions.github.io/japt/?v=2.0a0&code=ci9eICsvbUDTTWdYynogxMQp5w==&input=ImNsYXNzIEtscwogIGRlZiBtZXRob2QKICAgIHQgPSBUaW1lLm5vdwogICAgaWYgdC5ob3VyID49IDEyCiAgICAgIHB1dHMgYEl0J3MgYWZ0ZXJub29uYAogICAgICBpZiB0LmhvdXIgPT0gMTgKICAgICAgICBwdXRzIGBJdCdzIHRpbWUgZm9yIHlvdXIgbWVhbCBvZjpgCiAgICAgICAgJXcoYnJlYWQgc2F1c2FnZSBicm9jb2xsaSBtaWxrKS5lYWNoIGRvIHxmb29kfAogICAgICAgICAgYFNvbWUgI3tmb29kfWAKICAgICAgICBlbmQKICAgICAgZW5kCiAgICBlbHNlCiAgICAgIHB1dHMgYEl0J3Mgbm90IGFmdGVybm9vbmAKICAgIGVuZAogIGVuZCAKZW5kIg==)
---
## Explanation
```
r :Replace
/^ +/m :Global, multiline regular expression matching one or more spaces at the start of each line
_ :Pass each match through a function
Ê : Length
z : (Floor) divide by 2
õ : Range [0,result]
@ : Map each X
MgX : Xth Fibonacci number
à : End mapping
x : Reduce by addition
ç : Repeat <space> that many times
```
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), ~~87~~ 81 bytes
```
x=>x.replace(/^ */gm,s=>" ".repeat((g=(n,a=b=1)=>n?g(n-2,b,b+=a):b-1)(s.length)))
```
[Try it online!](https://tio.run/##ZY/BTsMwDIbve4pfRYgEuk7bCW1KOSOOcEZLW6ctpPGUZGyI8eylG9OmwcWyP/uz5Tf9oUPp21UcO66oN6rfqnybeVpZXZKYvOJ2UndpUHmCZI9JRyFqJVyqVaGmUuXuoRZuPEuLtLhTWs6L8VSKkFlydWyklP2iZBfYUma5FkYsS6tDwJMNI6Aig45iw9VQABEKL21HmePNAbQGMWt47ZErTGcHBqzWMSB5jDcB2kTyjtklx97ZUINxf6QXThwuwLDH536sI23BZp6cRq83ovCkKwS9DromFJ5LtrZF19p3mZEuG1SMnWGudicNSJ552Hz1teff533kqtFlRjbQ/18cx7///ApDxGgISykX/Q8 "JavaScript (Node.js) – Try It Online")
## For small indent levels (up to 15), 61 bytes using approximation:
```
x=>x.replace(/^ */gm,s=>" ".repeat(1.272**s.length*1.171-.5))
```
Use `1.27202 ** s.length * 1.17082 - .5` for indents up to 21 levels
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 62 bytes
```
*.trans(/[\n|^]' '+/=>{"\n"~' 'x(1,1,*+*...*)[$/.ords/2+1]-1})
```
[Try it online!](https://tio.run/##VYxdC4IwFIbv/RWnEemmbayLbsKi36EGhhOF2sKzKOnjr69hIXYuznmew8t7Ud1p7c49LGpIwTFuu1JjJLJcPw9FCGEs0u2D5Jq8vdwjmciExYxzzmg2F9x0FYpVLIulfFG3CbDsoY6IbVoMAIYFYLQarqf6BwC2USN7U2hx4gAzQse672evK59ozO0v56c8mqudFLcIO0LdBw "Perl 6 – Try It Online")
] |
[Question]
[
Okay, the challenge is that you have to write a regex that matches half of all strings.
Some rules to clarify:
For ANY string length(>0), if I permute all strings(of that length), exactly half of them should be matched. Put more lightly, if I generate a random string of that length it should have a 50% chance of being matched. (this means that you cannot just match all even-length strings)
You may assume that strings contain only A-Z, a-z, and 0-9.
0 length strings are undefined, you can choose to either match them or not.
Shortest regex wins.
[Answer]
## 6
```
/^[5-Z]/
```
In ASCII's order, there's 0-9 then A-Z then a-z
So Half of the string begin with 5-Z, the other half doesn't.
[Answer]
**9 characters (not counting leaning toothpicks)**
Modified mine from the comments:
```
/^[A-Z0-4]/
```
It will match half of all 1 character strings. Every string of length greater than one starts with a one character string, half of which will match. So half match in total.
[Answer]
# 6
```
/^[0-U]/
```
Ranges work for ascii values, so this matches half of the 62 combinations of first letters. Can match the empty string for one extra char:
```
/^[0-U]?/
```
For more confusion, this is also a solution:
```
/^[--U]/
```
Also this:
```
/^[-U]/
```
where the ascii 0 is right before the `-`.
[Answer]
## 24
You didn't ask for a max length.
So an infinity of strings can exist.
Half of infinity = infinity.
But that doesn't lead anywhere.
Anyway, I'd say that "half of this infinite number of strings" start with [A-Z0-4] and the other half with [a-z5-9]
That's why I consider this answer correct (inspired by Tim Seguine)
```
/^[A-Z0-4][A-Za-z0-9]*$/
```
] |
[Question]
[
The task is to build a numerical library for working with arbitrarily large integers that supports the following operations:
* addition
* subtraction
* multiplication
* division
* modulo operation
However, the library **must not use any [primitive data types](https://en.wikipedia.org/wiki/Primitive_data_type) or arrays**, neither directly nor indirectly (including booleans). For example, if you use Java, you can neither use [AtomicInteger](http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/atomic/AtomicBoolean.html) (because it uses `bool` internally) nor [HashMap](http://docs.oracle.com/javase/7/docs/api/java/util/HashMap.html) (because it uses arrays internally). You'll need to create your own data structures, without using any primitive data types, to represent numbers. (Inherited methods such as Java's `hashCode` don't count, as long as you don't use them in any way.) The only exception is local use of booleans in order to use conditionals (see the clarification points below).
There is only one exception: In order to make your library actually testable, provide two functions to convert from and to native integer representation. For example:
```
int toNative(MyNum n) { ... }
MyNum fromNative(int n) { ... }
```
This is the only part of your code that can use built-in data types, and it must not do anything except the conversion.
If in doubt, please ask.
Criteria: The code should be elegant, *readable*, concise (but no code-golf, readability is more important than code size), well documented, and if possible, asymptotically efficient (provide and justify your functions asymptotic time and space complexity). The most up-voted answer in 10 days wins.
---
**Update:** Since the puzzle seemed impossible to many people, let me give **a hint**:
```
public abstract class Nat {
public static Nat fromInt(int n) {
Nat r = new Zero();
for(int i = 0; i < n; i++)
r = new Succ(r);
return r;
}
public static int toInt(Nat n) {
int i = 0;
for(Nat m = n; m instanceof Succ; m = ((Succ)m).n)
i++;
return i;
}
}
final class Zero extends Nat {
}
final class Succ extends Nat {
public final Nat n;
public Succ(Nat n) {
this.n = n;
}
}
```
This allows to represent any natural number without primitive types, even though not very efficiently.
To further clarify:
* Pointers are allowed to work with data structures as long as you use them only as opaque references. In particular, you may not use any pointer arithmetic.
* `NULL`/`null`s are allowed.
* If the language of your choice requires it, you can use booleans (or a similar data type) for conditionals, but only locally in functions/methods, not as fields in your data structures, and you can't use anything beyond boolean operations. Bonus if you manage it without booleans (many languages are capable of that, such as those that use [pattern matching](http://en.wikipedia.org/wiki/Pattern_matching)).
* Higher-level languages are better suited for the puzzle.
[Answer]
## Haskell
Haskell is pretty good at defining obvious things from scratch.
Almost all definitions are simple translations of math axioms.
Doesn't support negative numbers, behaves badly on errors (e.g. `1-2` or `1/0`).
```
data MyNum = Zero | S MyNum
toNative :: MyNum -> Integer
toNative Zero = 0
toNative (S n) = (toNative n) + 1
fromNative :: Integer -> MyNum
fromNative 0 = Zero
fromNative n = S $ fromNative $ n-1
-- numIfGE a b c = c if a>=b else 0
numIfGE _ Zero n = n
numIfGE Zero _ n = Zero
numIfGE (S a) (S b) n = numIfGE a b n
instance Num MyNum where
a + Zero = a
a + (S b) = S (a + b)
a - Zero = a
(S a) - (S b) = a - b
a * Zero = Zero
a * (S b) = a + (a*b)
a `divi` b = numIfGE a b (S $ (a - b) `divi` b)
a `modu` b = a - ((a `divi` b) * b)
```
[Answer]
### Python 3
The code is a basic lambda calculus implementation I did some time ago when learning about calculus using an online resource which I cannot find anymore (can anybody give me a hint).
It works fine for positive numbers - extension to negatives should be possible.
```
# booleans and if
TRUE = lambda x: lambda y: x
FALSE = lambda x: lambda y: y
IF = lambda x: x
# numerals
ZERO = lambda f: lambda x: x
IS_ZERO = lambda n: n(lambda x: FALSE)(TRUE)
INC = lambda n: lambda f: lambda x: f(n(f)(x))
DEC = lambda n: lambda f: lambda x: n(lambda g: lambda h: h(g(f)))(lambda y: x)(lambda y: y)
# combinators
Y = lambda f: (lambda x: f(x(x)))(lambda x: f(x(x)))
Z = lambda f: (lambda x: f(lambda y: x(x)(y)))(lambda x: f(lambda y: x(x)(y)))
# arithmetic
ADD = lambda m: lambda n: n(INC)(m)
SUB = lambda m: lambda n: n(DEC)(m)
MUL = lambda m: lambda n: n(ADD(n))(ZERO)
IS_LEQ = lambda m: lambda n: IS_ZERO(SUB(m)(n))
MOD = Z(lambda f: lambda m: lambda n: IF(IS_LEQ(n)(m))(lambda x: f(SUB(m)(n))(n)(x))(m))
DIV = Z(lambda f: lambda m: lambda n: IF(IS_LEQ(n)(m))(lambda x: INC(f(SUB(m)(n))(n))(x))(ZERO))
# conversion function
def toNative(n) : return n(lambda x: x+1)(0)
def fromNative(n) : return ZERO if n==0 else INC(fromNative(n-1))
# Test code
n13 = fromNative(13)
n5 = fromNative(5)
print("13/5 = ",toNative(DIV(n13)(n5)))
print("13%5 = ",toNative(MOD(n13)(n5)))
```
[Answer]
# Haskell
**unlimited range, negative and positive values, no booleans** except in native code
**O(n)** addition, subtraction (**asymptotically optimal**)
**O(n^2)** multiplication, division/modulo (no, I'm not going to implement the [Karatsuba algorithm](http://en.wikipedia.org/wiki/Karatsuba_algorithm))
The representation is: a recursive type representing linked list of bits of the two's complement representation in the little endian order, terminated by either "all zeroes" or "all ones". Haskell has no trouble storing infinite lists in memory, but comparing their last elements is quite... hard.
`show` (producing a display form) runs backwards because prepending to a string is much faster than appending to it.
Addition, successor and predecessor are very simple. Carry is performed using the `succ`essor function. Note I didn't have to define subtraction. Haskell defines it for all `Num`bers as `a - b = a + negate b)`.
Multiplication is the classical binary [lattice multiplication](http://en.wikipedia.org/wiki/Multiplication_algorithm#Lattice_multiplication), with the sum step being performed bottom-up.
Division is the classical binary [long division](http://en.wikipedia.org/wiki/Long_division) (trial subtraction).
Haskell defines two sets of integer division operations. `quot`ient/`rem`ainder round the quotient towards zero, while `div`ision/`mod`ulo round the quotient towards negative infinity. It defines `divMod` in terms of `quotRem` by subtracting one from the quotient (and the divisor from the modulus) if the sign of the remainder is opposite the sign of the divisor [[source](http://www.haskell.org/ghc/docs/7.6.2/html/libraries/base/src/GHC-Real.html#Integral)]. This is also the only place where the standard implementation uses native booleans internally (pattern matching probably does as well, but by the word of the author, this doeesn't count).
```
data LinkedInteger = Zero | MOne | And0 LinkedInteger | And1 LinkedInteger
toNative Zero = 0
toNative MOne = -1
toNative (And0 x) = 2 * toNative x
toNative (And1 x) = 2 * toNative x + 1
instance Show LinkedInteger where
show = reverse.rshow
where rshow Zero = "0.. "
rshow MOne = "1.. "
rshow (And0 x) = '0':(rshow x)
rshow (And1 x) = '1':(rshow x)
fromNative 0 = Zero
fromNative (-1) = MOne
fromNative x | odd x = And1 $ fromNative(x`div`2)
| even x = And0 $ fromNative(x`div`2)
instance Enum LinkedInteger where
succ Zero = And1 Zero
succ MOne = Zero
succ(And0 x) = And1 x
succ(And1 x) = And0(succ x)
pred Zero = MOne
pred MOne = And0 MOne
pred(And0 x) = And1(pred x)
pred(And1 x) = And0 x
toEnum = fromNative
fromEnum = toNative
instance Num LinkedInteger where
-- ensures sublinear performance in most cases
Zero + x = x
x + Zero = x
MOne + x = pred x
x + MOne = pred x
And0 x + And0 y = And0 (x+y)
And0 x + And1 y = And1 (x+y)
And1 x + And0 y = And1 (x+y)
And1 x + And1 y = And0 $ succ (x+y)
negate Zero = Zero
negate MOne = And1 Zero
negate (And0 x) = And0 (negate x)
negate (And1 x) = And1 $ pred (negate x)
Zero * y = Zero
MOne * y = -y
And0 x * y = And0 (x*y)
And1 x * y = y + And0 (x*y)
fromInteger = fromNative
signum x = signum' (compare x Zero)
where signum' LT = MOne
signum' EQ = Zero
signum' GT = And1 Zero
abs x = ifNeg x (-x) x
mappend EQ y = y
mappend x _ = x
instance Eq LinkedInteger where x == y = (compare x y) == EQ
instance Ord LinkedInteger where
compare Zero Zero = EQ
compare MOne MOne = EQ
compare MOne Zero = LT
compare Zero MOne = GT
compare (And0 x) (And0 y) = compare x y
compare (And1 x) (And1 y) = compare x y
compare (And0 x) (And1 y) = mappend (compare x y) LT
compare (And1 x) (And0 y) = mappend (compare x y) GT
compare Zero x = compare (And0 Zero) x
compare MOne x = compare (And1 MOne) x
compare x Zero = compare x (And0 Zero)
compare x MOne = compare x (And1 MOne)
ifLt w x y z = ifNeg' (compare w x) y z
where ifNeg' LT y _ = y
ifNeg' _ _ z = z
ifNeg x = ifLt x 0
half Zero = Zero
half MOne = MOne
half (And0 x) = x
half (And1 x) = x
andBitFrom Zero = And0
andBitFrom MOne = And1
andBitFrom (And0 x) = And0
andBitFrom (And1 x) = And1
instance Real LinkedInteger where toRational = toNative
instance Integral LinkedInteger where
quotRem _ Zero = undefined
quotRem x y = (ifNeg x
(ifNeg y
(let n (q,r) = ( q, -r) in n(quotRem'(-x)(-y)))
(let n (q,r) = (-q, -r) in n(quotRem'(-x) y )))
(ifNeg y
(let n (q,r) = (-q, r) in n(quotRem' x (-y)))
(quotRem' x y ) ))
where quotRem' Zero _ = (Zero, Zero)
quotRem' x y =
let (qHalf, rHalf) = quotRem' (half x) y
subdiv = andBitFrom(x) rHalf
subdiv' = subdiv - y
in ifNeg subdiv' (And0 qHalf, subdiv) (And1 qHalf, subdiv')
toInteger = toNative
```
[Answer]
## perl
Here's my take, in perl. I thought this was a code-golfing post at first, so you may see some vestiges of that in the code. Anyway, I went to some effort to make the code as "tight" as possible, probably a little tighter than I otherwise would have. But I didn't go too far over the deep-end. Also note that I left in the prototypes on public functions (despite them being considered bad practice), because it made the test cases much less tedious to code up.
As for time and space, I left notation of the runtimes in the source at the heading of each subroutine, but I didn't take the time to prove them or anything, just to convince myself. Space is the more serious consideration of course - this implementation uses O(n) space to store an integer n, which is pretty bad. I wasn't sure exactly what I could get away with in terms of chars or encoding counts in inheritance patterns and such so I figured I'd do it the "canonical" (if slower) way. This has other effects too, for example, it takes O(n+m) time to ask if n equals m.
All that said, here's nat.pm, a complete (I believe) implementation in perl:
```
#!/usr/bin/perl
use strict;
use warnings;
package nat;
sub prev() { $_[0]->{prev}; }
sub next() { $_[0]->{next}; }
sub zero() { bless { prev => undef, next => undef } }
sub inc($) {
bless defined $_[0]->next ?
{ prev => undef, next => $_[0]->next->next } :
{ prev => $_[0], next => undef }
}
sub dec($) {
bless defined $_[0]->prev ?
{ prev => $_[0]->prev->prev, next => undef } :
{ prev => undef, next => $_[0] }
}
sub is_zero($) { !defined $_[0]->prev && !defined $_[0]->next };
sub is_negative($) { defined $_[0]->next };
sub is_positive($) { defined $_[0]->prev };
sub from_native($) {
my ($n) = @_;
my $x = zero;
$n--, $x = inc($x) while $n > 0;
$n++, $x = dec($x) while $n < 0;
return $x;
}
sub to_native($) {
my ($x) = @_;
my $n = 0;
--$n, $x = $x->next while defined $x->next;
++$n, $x = $x->prev while defined $x->prev;
return $n;
}
# returns 1 if x has greater magnitude than y
# returns -1 if x has lesser magnitude than y
# returns 0 if x and y have the same magnitude
sub _equal_depth { # O(x+y)
my ($x, $y, $c) = @_;
while( defined $x->{$c} ) {
return 1 if !defined $y->{$c};
$x = $x->{$c};
$y = $y->{$c};
}
return defined $y->{$c} ? -1 : 0;
}
# x<y => -1, x>y => 1, x==y => 0
sub spaceship($$) { # O(x+y)
my ($x, $y) = @_;
if( is_positive( $x ) ) {
return is_positive( $y ) ? _equal_depth($x, $y, 'prev') : 1;
} elsif( is_negative( $x ) ) {
return is_negative( $y ) ? _equal_depth($y, $x, 'next') : -1;
} else {
return is_zero( $y ) ? 0 : is_positive( $y ) ? -1 : 1;
}
}
# the below are all O(x+y) as a result of spaceship()
#sub is_lt($$) { my ($x, $y) = @_; return spaceship($x, $y) == -1 }
#sub is_gt($$) { my ($x, $y) = @_; return spaceship($x, $y) == 1 }
#sub is_le($$) { my ($x, $y) = @_; return spaceship($x, $y) != 1 }
#sub is_ge($$) { my ($x, $y) = @_; return spaceship($x, $y) != -1 }
sub equals($$) { my ($x, $y) = @_; return spaceship($x, $y) == 0 }
sub clone($) { # O(x)
my ($x) = @_;
my $r = zero;
if( is_positive($x) ) {
$x = $x->prev, $r = inc($r) while defined $x->prev;
} elsif( is_negative($x) ) {
$x = $x->next, $r = dec($r) while defined $x->next;
}
return $r;
}
sub _add_sub { # O(x+y)
my $is_sub = pop;
my ($x, $y) = map { clone($_) } @_;
while( 1 ) {
if( is_positive( $y ) ) {
$y = dec( $y );
$x = $is_sub ? dec( $x ) : inc( $x );
} elsif( is_negative( $y ) ) {
$y = inc( $y );
$x = $is_sub ? inc( $x ) : dec( $x );
} else {
last;
}
}
return $x;
}
sub add($$) { # O(x+y)
return _add_sub(@_, 0);
}
sub minus($$) { # O(x+y)
return _add_sub(@_, 1);
}
sub negate($) {
my ($x) = @_;
return minus( zero, $x );
}
sub magnitude($) {
my ($x) = @_;
return is_negative($x) ? negate($x) : $x;
}
sub mult($$) { # O(x*y)
my ($x, $y) = map { clone($_) } @_;
my $r = zero;
$x = negate($x), $y = negate($y) if is_negative($y);
while( !is_zero( $y ) ) {
$r = add($r, $x);
$y = dec( $y );
}
return $r;
}
sub _div { # O(x*y)
my $is_mod = pop;
my ($x, $y) = map { clone($_) } @_;
die "tried to divide by zero" if is_zero( $y );
if($is_mod && (is_negative($x) || is_negative($y))) {
if('nat.t' ne (caller(1))[1]) {
warn "warning: modular arithmetic with negative operands not well defined!\n";
}
}
my $is_neg = ( is_negative($x) xor is_negative($y) );
$x = magnitude($x);
$y = magnitude($y);
# count up from zero by one until we get to $x
# whenever we get to a multiple, increment the result by one and zero the remainder
my $q = zero;
my $r = zero;
while( !is_zero( $x ) ) {
$r = inc( $r );
if( equals( $y, $r ) ) {
$r = zero;
$q = inc( $q );
}
$x = dec( $x );
}
$r = negate($r), $q = negate($q) if $is_neg;
return $is_mod ? $r : $q;
}
sub divi($$) {
return _div(@_, 0);
}
sub mod($$) {
return _div(@_, 1);
}
# export
no strict 'refs';
*{scalar(caller)."::$_"} = \&$_ for grep { !/^[A-Z_]/ } keys %nat::;
1;
```
... and here is the test script I used when building it:
```
#!/usr/bin/perl
use strict;
use warnings;
use Test::More;
use nat;
my $x;
my $zero = zero;
ok( $zero );
ok( 0 == to_native $zero );
ok( is_zero $zero );
ok( !is_negative $zero );
ok( !is_positive $zero );
my $pos1 = inc $zero;
ok( $pos1 );
ok( 1 == to_native $pos1 );
ok( 0 == to_native dec $pos1 );
ok( !is_zero $pos1 );
ok( !is_negative $pos1 );
ok( is_positive $pos1 );
my $neg1 = dec $zero;
ok( $neg1 );
ok( -1 == to_native $neg1 );
ok( 0 == to_native inc $neg1 );
ok( !is_zero $neg1 );
ok( is_negative $neg1 );
ok( !is_positive $neg1 );
my $pos2 = inc $pos1;
ok( $pos2 );
ok( 2 == to_native $pos2 );
ok( 3 == to_native inc $pos2 );
ok( 1 == to_native dec $pos2 );
ok( !is_zero $pos2 );
ok( !is_negative $pos2 );
ok( is_positive $pos2 );
my $neg3 = dec dec $neg1;
ok( $neg3 );
ok( -3 == to_native $neg3 );
ok( -2 == to_native inc $neg3 );
ok( -4 == to_native dec $neg3 );
ok( !is_zero $neg3 );
ok( is_negative $neg3 );
ok( !is_positive $neg3 );
# make sure inc/dec can go "across" zero
ok( 1 == to_native inc inc inc dec dec zero );
ok( -1 == to_native dec dec dec inc inc zero );
ok( equals $zero, $zero );
ok( !equals $zero, $pos1 );
ok( !equals $zero, $neg1 );
ok( !equals $pos1, $neg1 );
ok( !equals $pos1, $pos2 );
ok( equals $pos1, $pos1 );
ok( equals $pos2, $pos2 );
ok( !equals $neg1, $neg3 );
ok( equals $neg1, $neg1 );
ok( equals $neg3, $neg3 );
ok( 0 == spaceship $neg3, $neg3 );
ok( 0 == spaceship $neg3, $neg3 );
ok( -1 == spaceship $neg3, $neg1 );
ok( 1 == spaceship $neg1, $neg3 );
ok( -1 == spaceship $neg3, $zero );
ok( 1 == spaceship $zero, $neg3 );
ok( -1 == spaceship $neg3, $pos1 );
ok( 1 == spaceship $pos1, $neg3 );
ok( -1 == spaceship $neg3, $pos2 );
ok( 1 == spaceship $pos2, $neg3 );
ok( 0 == spaceship $neg1, $neg1 );
ok( 0 == spaceship $neg1, $neg1 );
ok( -1 == spaceship $neg1, $zero );
ok( 1 == spaceship $zero, $neg1 );
ok( -1 == spaceship $neg1, $pos1 );
ok( 1 == spaceship $pos1, $neg1 );
ok( -1 == spaceship $neg1, $pos2 );
ok( 1 == spaceship $pos2, $neg1 );
ok( 0 == spaceship $zero, $zero );
ok( 0 == spaceship $zero, $zero );
ok( -1 == spaceship $zero, $pos1 );
ok( 1 == spaceship $pos1, $zero );
ok( -1 == spaceship $zero, $pos2 );
ok( 1 == spaceship $pos2, $zero );
ok( 0 == spaceship $pos1, $pos1 );
ok( 0 == spaceship $pos1, $pos1 );
ok( -1 == spaceship $pos1, $pos2 );
ok( 1 == spaceship $pos2, $pos1 );
ok( 0 == spaceship $pos2, $pos2 );
ok( 0 == spaceship $pos2, $pos2 );
#ok( is_lt $neg3, $neg1 );
#ok( !is_lt $neg3, $neg3 );
#ok( is_le $neg3, $neg1 );
#ok( is_le $neg1, $neg1 );
#ok( !is_gt $neg3, $neg1 );
#ok( !is_gt $neg3, $neg3 );
#ok( !is_ge $neg3, $neg1 );
#ok( is_ge $neg1, $neg1 );
ok( equals( inc inc inc inc inc inc zero, from_native 6 ) );
ok( equals( dec dec dec dec dec dec dec zero, from_native -7 ) );
$x = clone $pos2;
ok( equals $pos2, $x );
ok( 2 == to_native $x );
$x = clone $neg3;
ok( equals $neg3, $x );
ok( -3 == to_native $x );
ok( 2 == to_native add $zero, $pos2 );
ok( 1 == to_native add $zero, $pos1 );
ok( 1 == to_native add $pos1, $zero );
ok( 2 == to_native add $pos1, $pos1 );
ok( 3 == to_native add $pos1, $pos2 );
ok( 3 == to_native add $pos2, $pos1 );
ok( 4 == to_native add $pos2, $pos2 );
ok( -3 == to_native add $zero, $neg3 );
ok( -1 == to_native add $zero, $neg1 );
ok( -1 == to_native add $neg1, $zero );
ok( -2 == to_native add $neg1, $neg1 );
ok( -4 == to_native add $neg1, $neg3 );
ok( -4 == to_native add $neg3, $neg1 );
ok( -6 == to_native add $neg3, $neg3 );
ok( -2 == to_native add $neg3, $pos1 );
ok( -1 == to_native add $neg3, $pos2 );
ok( 0 == to_native add $neg1, $pos1 );
ok( 1 == to_native add $neg1, $pos2 );
ok( -2 == to_native minus $neg3, $neg1 );
ok( 2 == to_native minus $neg1, $neg3 );
ok( -3 == to_native minus $neg3, $zero );
ok( 3 == to_native minus $zero, $neg3 );
ok( -4 == to_native minus $neg3, $pos1 );
ok( 4 == to_native minus $pos1, $neg3 );
ok( -5 == to_native minus $neg3, $pos2 );
ok( 5 == to_native minus $pos2, $neg3 );
ok( -1 == to_native minus $neg1, $zero );
ok( 1 == to_native minus $zero, $neg1 );
ok( -2 == to_native minus $neg1, $pos1 );
ok( 2 == to_native minus $pos1, $neg1 );
ok( -3 == to_native minus $neg1, $pos2 );
ok( 3 == to_native minus $pos2, $neg1 );
ok( -1 == to_native minus $zero, $pos1 );
ok( 1 == to_native minus $pos1, $zero );
ok( -2 == to_native minus $zero, $pos2 );
ok( 2 == to_native minus $pos2, $zero );
ok( -1 == to_native minus $pos1, $pos2 );
ok( 1 == to_native minus $pos2, $pos1 );
ok( equals $pos1, negate($neg1) );
ok( equals $neg1, negate($pos1) );
ok( 3 == to_native negate $neg3 );
ok( 1 == to_native negate $neg1 );
ok( 0 == to_native negate $zero );
ok( -1 == to_native negate $pos1 );
ok( -2 == to_native negate $pos2 );
ok( equals magnitude($pos1), magnitude($neg1) );
ok( equals magnitude($neg1), magnitude($pos1) );
ok( equals magnitude($pos1), $pos1 );
ok( equals magnitude($neg1), $pos1 );
ok( 3 == to_native magnitude $neg3 );
ok( 1 == to_native magnitude $neg1 );
ok( 0 == to_native magnitude $zero );
ok( 1 == to_native magnitude $pos1 );
ok( 2 == to_native magnitude $pos2 );
ok( 3 == to_native mult $neg3, $neg1 );
ok( 0 == to_native mult $neg3, $zero );
ok( -3 == to_native mult $neg3, $pos1 );
ok( -6 == to_native mult $neg3, $pos2 );
ok( 1 == to_native mult $neg1, $neg1 );
ok( 0 == to_native mult $neg1, $zero );
ok( -1 == to_native mult $neg1, $pos1 );
ok( -2 == to_native mult $neg1, $pos2 );
ok( 0 == to_native mult $zero, $zero );
ok( 0 == to_native mult $zero, $pos1 );
ok( 0 == to_native mult $zero, $pos2 );
ok( 1 == to_native mult $pos1, $pos1 );
ok( 2 == to_native mult $pos1, $pos2 );
ok( 4 == to_native mult $pos2, $pos2 );
ok( 3 == to_native divi $neg3, $neg1 );
ok( 0 == to_native divi $neg1, $neg3 );
eval { to_native divi $neg3, $zero }; ok($@);
ok( 0 == to_native divi $zero, $neg3 );
ok( -3 == to_native divi $neg3, $pos1 );
ok( 0 == to_native divi $pos1, $neg3 );
ok( -1 == to_native divi $neg3, $pos2 );
ok( 0 == to_native divi $pos2, $neg3 );
eval { to_native divi $neg1, $zero }; ok($@);
ok( 0 == to_native divi $zero, $neg1 );
ok( -1 == to_native divi $neg1, $pos1 );
ok( -1 == to_native divi $pos1, $neg1 );
ok( 0 == to_native divi $neg1, $pos2 );
ok( -2 == to_native divi $pos2, $neg1 );
ok( 0 == to_native divi $zero, $pos1 );
eval { to_native divi $pos1, $zero }; ok($@);
ok( 0 == to_native divi $zero, $pos2 );
eval { to_native divi $pos2, $zero }; ok($@);
ok( 0 == to_native divi $pos1, $pos2 );
ok( 2 == to_native divi $pos2, $pos1 );
ok( 0 == to_native divi from_native(0), from_native(3) );
ok( 0 == to_native mod from_native(0), from_native(3) );
ok( 0 == to_native divi from_native(1), from_native(3) );
ok( 1 == to_native mod from_native(1), from_native(3) );
ok( 0 == to_native divi from_native(2), from_native(3) );
ok( 2 == to_native mod from_native(2), from_native(3) );
ok( 1 == to_native divi from_native(3), from_native(3) );
ok( 0 == to_native mod from_native(3), from_native(3) );
ok( 1 == to_native divi from_native(4), from_native(3) );
ok( 1 == to_native mod from_native(4), from_native(3) );
ok( 1 == to_native divi from_native(5), from_native(3) );
ok( 2 == to_native mod from_native(5), from_native(3) );
ok( 2 == to_native divi from_native(6), from_native(3) );
ok( 0 == to_native mod from_native(6), from_native(3) );
ok( 2 == to_native divi from_native(7), from_native(3) );
ok( 1 == to_native mod from_native(7), from_native(3) );
ok( 0 == to_native divi from_native(-1), from_native(3) );
ok( -1 == to_native mod from_native(-1), from_native(3) );
ok( 0 == to_native divi from_native(-2), from_native(3) );
ok( -2 == to_native mod from_native(-2), from_native(3) );
ok( -1 == to_native divi from_native(-3), from_native(3) );
ok( 0 == to_native mod from_native(-3), from_native(3) );
ok( -1 == to_native divi from_native(-4), from_native(3) );
ok( -1 == to_native mod from_native(-4), from_native(3) );
done_testing();
```
[Answer]
# Go
Here's my partial submission in Go. Handles conversion to/from uint and sum to arbitrary precision.
The representation is binary, using a struct field (Unf) to store 1 bit of information (whether the pointer is nil or not) and another field (Chooie) to chain the next bit (more significant) which will chain another one if needed, and so on.
The performance is logarithmic with respect to the actual integers, just like in regular arbitrary precision libraries, except that the constant factors are hugely different.
```
package TerribleSecret
type Unf struct {
Pak, Chooie *Unf
}
func FromNative(n uint) (u *Unf) {
u = new(Unf)
if n == 0 {
return
}
if n&1 != 0 {
u.Pak = u
}
u.Chooie = FromNative(n >> 1)
return
}
func (u *Unf) ToNative() (n uint) {
if u == nil {
return
}
n = u.Chooie.ToNative()
n <<= 1
if u.Pak != nil {
n |= 1
}
return
}
func (u *Unf) Add(n *Unf) {
var f *Unf
for {
if u == nil {
u = new(Unf)
}
if (n == nil || n.Pak == nil) != (f == nil) {
if u.Pak != nil {
u.Pak = nil
} else {
u.Pak = u
}
}
if u.Pak != nil && (n == nil || n.Pak == nil) && f != nil {
f = nil
} else if u.Pak == nil && n != nil && n.Pak != nil && f == nil {
f = n.Pak
}
if n != nil {
n = n.Chooie
}
if n == nil && f == nil {
break
}
if u.Chooie == nil {
u.Chooie = new(Unf)
}
u = u.Chooie
}
}
```
**Unit tests**
```
package TerribleSecret
import "testing"
func TestConversion(t *testing.T) {
for n := uint(0); n < 10000; n++ {
if r := FromNative(n).ToNative(); r != n {
t.Fatalf("%d != %d", n, r)
}
}
}
func TestAdd(t *testing.T) {
for x := uint(0); x < 1000; x++ {
px := FromNative(x)
for y := uint(0); y < 1000; y++ {
py := FromNative(y)
py.Add(px)
if r := py.ToNative(); r != x+y {
t.Fatalf("%d + %d = %d != %d", x, y, x+y, r)
}
}
}
}
```
[Answer]
# C#
Supports the 5 operations and negative values.
```
using System;
namespace NonPrimitive
{
enum ComparisonResult
{
Greater, Equal, Less, Error
}
class MainClass
{
static void Main ()
{
Leaf l1 = Leaf.FromInt (10);
Leaf l2 = Leaf.FromInt (-20);
Leaf l3 = Leaf.FromInt (30);
Leaf l4 = Leaf.FromInt (40);
Leaf l5 = Leaf.FromInt (50);
Leaf l6 = Leaf.FromInt (60);
Leaf l7 = Leaf.FromInt (-20);
Leaf l8 = Leaf.FromInt (80);
Leaf l9 = Leaf.FromInt (20);
Leaf l0 = Leaf.FromInt (50);
Leaf a = l1.Add (l2);
Leaf s = l4.Subtract (l3);
Leaf m = l6.Multiply (l5);
Leaf d = l8.Divide (l7);
Leaf mo = l0.Modulo (l9);
Console.WriteLine ("10 + -20: {0}", a.ToInt ());
Console.WriteLine ("40 - 30: {0}", s.ToInt ());
Console.WriteLine ("60 x 50: {0}", m.ToInt ());
Console.WriteLine ("80 / -20: {0}", d.ToInt ());
Console.WriteLine ("50 % 20: {0}", mo.ToInt ());
}
}
class Leaf
{
public Leaf Parent;
public Leaf Child;
public Leaf Negative;
public Leaf (Leaf parent)
{
Parent = parent;
}
public Leaf ReverseSign()
{
Leaf k = this.GetGrandParent ();
if(k.Negative != null)
k.Negative = null;
else
k.Negative = new Leaf(null);
return k;
}
public Leaf CreateNewLeaf()
{
Child = new Leaf(this);
return Child;
}
public Leaf AttachLeaf(Leaf leaf)
{
Child = leaf;
Child.Parent = this;
return this;
}
public Leaf RemoveChild()
{
this.Child = null;
return this;
}
public Leaf GetGrandChild ()
{
Leaf k = this;
while(k.Child != null)
k = k.Child;
return k;
}
public Leaf Add (Leaf a)
{
Leaf t = this.GetGrandChild ().AttachLeaf (a.GetGrandParent ()).GetGrandChild ().Parent.RemoveChild ().GetGrandParent ();
if ((a.Negative == null && this.Negative == null) ||
(a.Negative != null && this.Negative != null))
return t.GetGrandParent ();
return t.GetGrandParent ().ReverseSign ();
}
public Leaf GetGrandParent ()
{
Leaf k = this;
while(k.Parent != null)
k = k.Parent;
return k;
}
public Leaf Multiply (Leaf t)
{
Leaf ret = new Leaf(null);
bool sign = (t.Negative == null && this.Negative == null) ||
(t.Negative != null && this.Negative != null);
t = t.GetGrandParent ();
Leaf temp = this;
while (t.Child != null) {
while(true)
{
if(temp.Child == null)
break;
ret = ret.CreateNewLeaf ();
temp = temp.Child;
}
temp = this.GetGrandParent ();
t = t.Child;
}
if(!sign)
return ret.GetGrandParent ().ReverseSign ();
return ret.GetGrandParent ();
}
public Leaf Divide (Leaf t)
{
Leaf temp = this.GetGrandParent ();
bool sign = (t.Negative == null && this.Negative == null) ||
(t.Negative != null && this.Negative != null);
Leaf ret = new Leaf (null);
while (temp.Compare (t) == ComparisonResult.Greater || temp.Compare (t) == ComparisonResult.Equal) {
temp = temp.Subtract (t);
ret = ret.CreateNewLeaf ();
}
if(!sign)
return ret.GetGrandParent ().ReverseSign ();
return ret.GetGrandParent ();
}
public ComparisonResult Compare (Leaf a)
{
Leaf t = this.GetGrandParent ();
a = a.GetGrandParent ();
while (true) {
if(t.Child == null && a.Child != null)
return ComparisonResult.Less;
if(t.Child == null && a.Child == null)
return ComparisonResult.Equal;
if(t.Child != null && a.Child == null)
return ComparisonResult.Greater;
t = t.Child;
a = a.Child;
}
}
public Leaf Modulo(Leaf t)
{
Leaf temp = this.GetGrandParent ();
bool sign = (t.Negative == null && this.Negative == null) ||
(t.Negative != null && this.Negative != null);
while (temp.Compare (t) == ComparisonResult.Greater || temp.Compare (t) == ComparisonResult.Equal) {
temp = temp.Subtract (t);
}
if(!sign)
return temp.GetGrandParent ().ReverseSign ();
return temp.GetGrandParent ();
}
public Leaf Subtract (Leaf a)
{
Leaf temp = this.GetGrandParent();
a = a.GetGrandParent ();
Leaf counter = new Leaf (null);
while (true) {
if(a.Child != null && temp.Child != null) {
temp = temp.Child;
a = a.Child;
} else if (a.Child != null && temp.Child == null) {
a = a.Child;
counter = counter.CreateNewLeaf ();
} else if (temp.Child != null && a.Child == null) {
temp = temp.Child;
counter = counter.CreateNewLeaf ();
}
else if(temp.Child == null && a.Child == null) {
break;
}
}
a = a.GetGrandParent ();
if(this.Compare (a) == ComparisonResult.Less)
return counter.ReverseSign ();
else
return counter.GetGrandParent ();
}
public int ToInt()
{
Leaf temp = this.GetGrandParent ();
int ret = 0;
while(true)
{
if(temp.Child != null) {
ret++;
temp = temp.Child;
continue;
}
break;
}
if(this.Negative != null)
return -ret;
return ret;
}
public static Leaf FromInt (int a)
{
Leaf ret = new Leaf (null);
bool neg = a < 0;
if (neg)
a = Math.Abs (a);
for (int i = 0; i < a; i++) {
ret = ret.CreateNewLeaf ();
}
while (true) {
if(ret.Parent != null)
ret = ret.Parent;
else
break;
}
if(neg)
return ret.ReverseSign ();
return ret;
}
}
}
```
Also, the class is named "Leaf" because it uses a tree-like structure.
[Answer]
## Brainfuck (incomplete)
Adding?
```
,>,[-<+>]
```
Subtracting?
```
,>,[-<->]
```
[Answer]
# C++ lambda functions
```
#include <cstdio>
#include <functional>
using std::function;
typedef function<int(int, function<int(int)>)> church;
church zero = [](int x, function<int(int)> f){ return x; };
function<church(church)> successor = [](church n)
{
return [=](int x, function<int(int)> f)
{
return n(f(x),f);
};
};
function<church(church, church)> plus = [](church n, church m)
{
return [=](int x, function<int(int)> f)
{
return n(m(x, f), f);
};
};
function<church(church, church)> times = [](church n, church m)
{
return [=](int x, function<int(int)> f)
{
return m(x, [=](int y){ return n(y, f); });
};
};
int main()
{
function<int(int)> convert = [](int x){
return x + 1;
};
auto resf0 = successor(successor(zero));
int res0 = resf0(0, convert);
printf("%i\n", res0); // 2
auto resf1 = successor(resf0);
int res1 = resf1(0, convert);
printf("%i\n", res1); // 3
auto resf2 = plus(resf0, resf1);
int res2 = resf2(0, convert);
printf("%i\n", res2); // 5
auto resf3 = times(resf1, resf2);
int res3 = resf3(0, convert);
printf("%i\n", res3); // 15
}
```
This may not strictly follow the rules, but I wrote this, and somebody else revised it to this in August 2013. Ints are only used as a placeholder datatype, and also so that we can convert the weird function types to actual numbers.
] |
[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/6692/edit).
Closed 7 years ago.
[Improve this question](/posts/6692/edit)
The goal is to write a program that learns from its own mistakes, and improves itself based on it. This means, that later attempts at the problem should be either faster or more accurate, than earlier ones.
To deny trivial solutions, here is a set of rules (they are rather obvious):
* you can choose the problem to be solved, but your choice will be voted upon.
* the program should read input, this means the problem must have input variables, and its output should depend on that input.
* later runs of the algorithm should be better (at least after a certain number of runs) than the previous ones. Better can mean faster, or more optimal, or more accurate.
* the improvement must be real, and not just the disabling of purposefully introduced inhibitors like `if (never_run_before()) sleep(100);`
* the improvement must be caused by your program, and not external factors (like the OS giving faster access to a resource, if it was already opened or more often accessed before)
* the iterations can be either successive runs of the program while you save knowledge to a non-volatile storage, or you can have an interactive program which reads input again and again for successive runs of the algorithm.
* there should be improvement besides the situation where the algorithm runs faster given the exact same input data. (just storing previous results and doing nothing else would be too cheap). This means, there should be some improvement even if there is no repetition in the input data, for example if the task is to solve a maze, the input maze might be different each time.
* the algorithm must be part of your program, so the use of existing machine-learning tools is not allowed (otherwise it would be a too easy win for Matlab and its built-in neural network)
The score is: **number of characters - 5 \* score form votes**. It can be negative. Smallest wins. Winner will be selected not sooner than 10 days after the first valid solution, and has to have a positive vote score.
For voters: the golfing is already an independent part of the score, so pleas don't vote based on the amount of golfing, but on the cleverness of the solution and the hardness and originality of the chosen problem (a program playing a game against the user should worth more than a program calculating the digits of pi)
[Answer]
# GNU Octave / MATLAB, 14
```
f=@(n)n+sin(n)
```
You don't generally take a standard input with Octave programs, so this is a function which gives an improved estimate of pi after every call on its previous output. Sample run:
```
octave> f=@(n)n+sin(n);
octave> format 'long'
octave> n = 1;
octave> n = f(n)
n = 1.84147098480790
octave> n = f(n)
n = 2.80506170934973
octave> n = f(n)
n = 3.13527633289972
octave> n = f(n)
n = 3.14159261159065
octave> n = f(n)
n = 3.14159265358979
```
[Answer]
## Python, 12
This program golfs itself, improving its own score for this challenge. It takes two iterations to fully optimize itself.
initial program
```
print'print'
```
first output / second program
```
print
```
second output / third program: newline
third output / fourth program: empty
all subsequent programs: empty
] |
[Question]
[
**This question already has answers here**:
[Shortest code that raises a SIGSEGV](/questions/4399/shortest-code-that-raises-a-sigsegv)
(84 answers)
Closed 7 years ago.
Write the shortest program which, when run with no arguments, stdin, or user input, triggers a core dump.
Your code must behave this way when run on some common out-of-the-box Linux distribution. Other than installing support for your target language, you may not reconfigure the system to make it more fragile than it is as provided.
25-byte C example: `int main(){*((int*)0)=0;}` on my Ubuntu outputs
```
Segmentation fault (core dumped)
```
[Answer]
# C, 5 bytes
```
main;
```
[Try it online!](https://goo.gl/r5RTnz)
## Slightly longer, 7 bytes
```
main=0;
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 2 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
×ß
```
**[TryItOnline!](http://jelly.tryitonline.net/#code=w5fDnw&input=&debug=on)**
A dyadic atom (here `×`, but there are swathes of others) followed by the quick `ß` which instructs to call the same link (the whole line of code) with the same arity - calling it once more with any arity would also work, so, since it is the only line of code, `ß` could be replaced by any of `¢ÇçÑñ` (last link as a nilad, last link as a monad, last link as a dyad, next link as a monad, or next link as a dyad).
[Answer]
## NASM, 3 bytes
```
ret
```
I guess it tries to jump to whatever is on the default stack and immediately segfaults :).
Built with: `nasm -f elf64 golf.asm && ld golf.o -o golf`
[Answer]
## BASH, 10 bytes
```
kill -6 $$
```
kill -6 precisely does this
[Answer]
# C, 14 bytes
```
main(c){c/=0;}
```
It's that simple 8-)
] |
[Question]
[
# The Challenge
Write a program that can calculate how many times and how long a ball will bounce based on a few input variables.
---
# Input
There are three variables that will be passed. You can accept these however you like (user input, function call, etc). The variables are as follows:
1. height
2. velocity
3. "bounciness"
They must be passed in this order.
---
### Height
Height will be expressed as an integer, `H`, where `10^6 ≥ H ≥ 10`. The height is measured in arbitrary units, `u`, which have no effect on your program's output.
---
### Velocity
The velocity of the ball will be represented by an integer, `V`, where `10^6 ≥ V ≥ 1`. It is expressed as `Vu/s` (`V` units per second).
---
### Bounciness
The "bounciness" will be expressed as a decimal, `B`, where `0.00 ≤ B < 1.00`. The maximum precision of `B` will be the hundredths place (two digits after the decimal point).
---
# Output
You output will be two integers representing:
* number of times the ball will bounce before coming to rest, `N`
* how long it takes the ball to complete all of these bounces, `T`
---
# Calculation
To calculate the number of times the ball will bounce, you would continuously multiply the current height by the "bounciness" until it dipped below `1`. Once the result gets below `1`, you should round the height down to `0`, and stop calculating.
Each time these two are multiplied, the time is incremented by the quotient of the current height and velocity.
Intermediary calculations should have a minimum precision to the ten-thousandths (four digits after the decimal).
---
# Example 1
If the input is:
```
10 10 0.5
```
The following table shows the necessary calculations for each bounce:
```
Height Next Height Bounces
------ ------- ------ -------
10.0000 10.0000 * 0.5 = 5.0000 1
5.0000 5.0000 * 0.5 = 2.5000 1
2.5000 2.5000 * 0.5 = 1.2500 1
1.2500 1.2500 * 0.5 = 0.6250 1
-------
Total Bounces: 4
Time added
----------------
10.0000 / 10 = 1.0000
5.0000 / 10 = 0.5000
2.5000 / 10 = 0.2500
1.2500 / 10 = 0.1250
------
Total Time: 1.8750
```
At this point, the computation terminates because the height is less than `1`. The time is rounded up to yield `2`. These two integers should then either be returned or output as a string in this form:
```
4 2
```
---
# Example 2
If the input is:
```
50 15 0.7
```
The following table shows the necessary calculations for each bounce:
```
Height Next Height Bounces
------ ------- ------- -------
50.0000 50.0000 * 0.7 = 35.0000 1
35.0000 35.0000 * 0.7 = 24.5000 1
24.5000 24.5000 * 0.7 = 17.1500 1
17.1500 17.2500 * 0.7 = 12.0050 1
12.0050 12.0050 * 0.7 = 8.4035 1
8.4035 8.4035 * 0.7 = 5.8825 1
5.8825 5.8825 * 0.7 = 4.1177 1
4.1177 4.1177 * 0.7 = 2.8824 1
2.8824 2.8824 * 0.7 = 2.0177 1
2.0177 2.0177 * 0.7 = 1.4124 1
1.4124 1.4124 * 0.7 = 0.9887 1
--------
Total Bounces: 11
Time added
-----------
50.0000 / 15 = 3.3333
35.0000 / 15 = 2.3333
24.5000 / 15 = 1.6333
17.1500 / 15 = 1.1433
12.0050 / 15 = 0.8003
8.4035 / 15 = 0.5602
5.8825 / 15 = 0.3922
4.1177 / 15 = 0.2745
2.8824 / 15 = 0.1922
2.0177 / 15 = 0.1345
1.4124 / 15 = 0.0942
----------
Total Time: 10.8913
```
At this point, the computation terminates because the height is less than `1`. The time is rounded up to give `11`. These two integers should then either be returned or output as a string in this form:
```
11 11
```
# Scoreboard
For your score to appear on the board, it should be in this format:
```
# Language, Score
```
Or if you earned a bonus:
```
# Language, Score (Bytes - Bonus%)
```
```
function getURL(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function getAnswers(){$.ajax({url:getURL(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){var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),useData(answers)}})}function getOwnerName(e){return e.owner.display_name}function useData(e){var s=[];e.forEach(function(e){var a=e.body.replace(/<s>.*<\/s>/,"").replace(/<strike>.*<\/strike>/,"");console.log(a),VALID_HEAD.test(a)&&s.push({user:getOwnerName(e),language:a.match(VALID_HEAD)[1],score:+a.match(VALID_HEAD)[2],link:e.share_link})}),s.sort(function(e,s){var a=e.score,r=s.score;return a-r}),s.forEach(function(e,s){var a=$("#score-template").html();a=a.replace("{{RANK}}",s+1+"").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SCORE}}",e.score),a=$(a),$("#scores").append(a)})}var QUESTION_ID=58319,ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",answers=[],answer_ids,answers_hash,answer_page=1;getAnswers();var VALID_HEAD=/<h\d>([^\n,]*)[, ]*(\d+).*<\/h\d>/;
```
```
body{text-align:left!important}table thead{font-weight:700}table td{padding:10px 0 0 30px}#scores-cont{padding:10px;width:600px}#scores tr td:first-of-type{padding-left:0}
```
```
<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="scores-cont"><h2>Scores</h2><table class="score-table"><thead> <tr><td></td><td>User</td><td>Language</td><td>Score</td></tr></thead> <tbody id="scores"></tbody></table></div><table style="display: none"> <tbody id="score-template"><tr><td>{{RANK}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SCORE}}</td></tr></tbody></table>
```
[Answer]
# Python2, 84 82 bytes
```
from math import*
h,v,b=input()
n=ceil(-log(h,b))
print ceil(h*(b**n-1)/(b-1)/v),n
```
Closed forms, yay!
[Answer]
# TI-BASIC, 35
```
Prompt H,V,B
-int(logBASE(H,B
Disp -int(H/V(B^Ans-1)/(1-B
Ans
```
A port of [orlp's Python answer](https://codegolf.stackexchange.com/a/58323/39328).
[Answer]
## CoffeeScript, 62 bytes
```
f=(h,v,b,n=t=0)->(t+=h/v;h*=b;n++)while 1<=h;n+' '+Math.ceil t
```
[Answer]
# CJam, ~~31~~ ~~28~~ 29 bytes
Latest version rounds up time to next integer. I had missed that in the requirements. This adds 2 bytes, and saves 1 byte based on a suggestion by Dennis.
```
l~_3$W#2$mLm]@1$#(@(/@/@*m]S\
```
[Try it online](http://cjam.aditsu.net/#code=l~_3%24W%232%24mLm%5D%401%24%23(%40(%2F%40%2F%40*m%5DS%5C&input=50%2015%200.7)
Thanks to @ThomasKwa for suggesting the use of `mL` instead of the quotient of two separate logarithms.
This uses basic log laws for calculating the number of bounces, and then the sum of a geometric series, which I had to look up on [Wikipedia](https://en.wikipedia.org/wiki/Geometric_series).
Explanation:
```
l~ Get and interpret input.
_ Copy B, will need this later.
3$ Get copy of H to top.
W# Calculate H^-1 = 1/H as double.
2$ Get copy of B to top.
mL Log with base.
m] Ceiling. This is the number of bounces N.
@ Rotate one copy of B to top.
1$ Copy number of bounces to top.
# Exponent B^N.
( Subtract 1.
@ Get other copy of B to top.
( Subtract 1.
/ Divide the two values.
@/ Rotate V to top and divide.
@* Get H to top and multiply. This is T.
m] Ceiling for time.
S\ Swap a space between the two resulting values.
```
[Answer]
# Pyth, 27 bytes
```
L_/b1y_c*Qt^KvwJy.lQK*vwtKJ
```
Direct port of my Python answer. Takes input in the following format:
```
h
b
v
```
[Answer]
## PHP, 87 bytes
Takes three [command line arguments](https://php.net/manual/en/features.commandline.php).
```
<?for($h=$argv[1],$n=$t=0;$h=>1;$n++){$t+=$h/$argv[2];$h*=$argv[3];}echo"$n ".ceil($t);
```
] |
[Question]
[
**This question already has answers here**:
[Build a random number generator that passes the Diehard tests](/questions/10553/build-a-random-number-generator-that-passes-the-diehard-tests)
(11 answers)
Closed 9 years ago.
**Task:**
Make a random number generator. The catch is that you can't use *any* built-in randomness functions. Your random numbers must be anything between 0 and 100, though they do not have to be floating point.
**Rules:**
* It must produce a pseudorandom number.
* Randomness defined: If you run it `x` times, then `x` times again, the two sequences will be unlikely to be identical. Where 2 < x < 10.
* It is **not** required that your random number generator passes any specific test about the quality of the generated numbers, as long as the previous rule is respected.
* Any language is accepted, except Golfscript, [see here](http://meta.codegolf.stackexchange.com/questions/286/j-and-golfscript-suck-all-the-enjoyment-out-of-code-golf).
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest answer in bytes wins.
* You may not hard-code the output numbers or read them from a file.
* Post 5 numbers generated by your program.
* Good luck!
[Answer]
**C (46)**
The stack pointer is sort of a random number
```
main(x){printf("%d",((unsigned char)&x)%100);}
```
Numbers I got:
```
20
40
4
52
36
```
[Answer]
# python, 49
```
x=7
def r(x):print(x%100);return(69069*x+1)%2**32
```
This is my first time golfing, I think this is within the rules but I'm not sure. This is a simple linear congruential generator, with starting x value as seed. User time is not used. To use, type `x=r(x)`.
Here are the results:
```
7
84
25
62
47
```
[Answer]
# Linux utils and ALSA, 41
Not a winner, but possibly a more accurate source of random noise than the current time:
```
arecord -qfS32|od -l -j48 -N8|cut -c27-28
```
Sample 5 random numbers:
>
> 32 53 81 83 26
>
>
>
[Answer]
## Java - ~~250~~ 249 characters
```
import java.awt.*;class A{public static void main(String[]y)throws Exception{int z=200,u=z*z-1,n=7;java.awt.image.BufferedImage b=new Robot().createScreenCapture(new Rectangle(z,z));while(u>0)n^=b.getRGB(u/z,u--%z);System.out.println((n>>>1)%101);}}
```
It uses the topright 200x200 pixels of the screen as a source of randomness. The result is an integer between 0 and 100.
I runned it 5 times (this last version) and got this:
```
97
84
38
40
65
```
I had to move my windows around between each run.
Needless to say, it is a very poor random-generator:
* It is frequently predictable.
* It is easily stalled to keep giving always the same output.
* It is unlikely to produce each number between 0 and 100 with an equal probability.
So, this should not be used by any serious purpose.
[Answer]
## Java - 206 characters
```
class V{public static void main(String[]y)throws Exception{java.io.InputStream o=new java.net.URL("http://bit.ly/1gxstDI").openStream();int x,n=7;while((x=o.read())>0)n^=x;System.out.println((n>>>1)%101);}}
```
Similar to my previous answer. However, it is smaller and has some better randomness properties (but still bad). It fetches random data from <http://en.wikipedia.org/wiki/Special:random> as a seed (I am borrowing this idea from [this answer](https://codegolf.stackexchange.com/a/16399/3755)).
Running it five times, here is the output:
```
25
15
93
32
9
```
[Answer]
# bash, 17
```
date +%N|tail -c3
```
Outputs the last two digits of a nanosecond timestamp.
### Sample output
```
$ ./random
24
$ ./random
52
$ ./random
82
$ ./random
69
$ ./random
72
```
[Answer]
# APL, 9 chars
```
101|+/⎕TS
```
Nothing new. It sums the components of the TimeStamp vector (current year, month… down to ms) and takes the remainder mod 101.
[Answer]
# Python 2.7 - 82 bytes
```
import timeit
print timeit.Timer('for i in range(1000):i**i').timeit(1)*10000%100
```
This can definitely be golfed down more. I couldn't get `timeit` working when using `from timeit import*` but I think I only lost one character there. This is my first time using the module so I'm probably missing a lot of stuff that could save characters.
Times how long it takes in (seconds?) to calculate `i**i` for 0-999, multiplies that by 10000 and takes the modulus of 100 to get the result in the correct range.
Since this works off of hardware deviation rather than a pseudorandom formula like most programs do, you could even call this "more random" than `random.random()*100`. :)
(That last part probably isn't true, but until someone explains why I'll continue to believe it.)
[Answer]
## Perl, 17
Seems like predictability isn't so much of an issue here, so here's a simple one:
```
print time**3%101
```
Five outputs:
```
59
38
17
14
94
```
I hope this answer highlights the importance of objectively defining the question.
[Answer]
**PowerShell (66)**
```
[Convert]::ToInt32((""+([guid]::newguid())).SubString(0,2),16)%100
```
5 outputs:
```
10
92
13
84
0
```
[Answer]
### Ruby, 69
```
def r()(Time.now.to_f.to_s+$$.to_s+$-I.join).bytes.reduce(:+)%100;end
```
[Online Version](http://ideone.com/ZgkbBW) for testing. Uses the current time in ms, the process id ($$) and the runtime environment ($-I) for creating a pseudo-random number.
Output:
```
47
44
39
43
88
```
[Answer]
## Java, 99 chars
```
class b{public static void main(String[]a){System.out.println(System.nanoTime()/a.hashCode()%99);}}
75
28
34
88
16
```
If you want to be really really cheap:
**java 88 Chars**
```
class b{public static void main(String[]a){System.out.println(System.nanoTime()/9%99);}}
99
86
61
15
19
```
[Answer]
# Smalltalk, 39
not a production quality random generator:
```
OperatingSystem getMicrosecondTime\\101
```
but as I generated those 5 values by eval'ing them interactively, it's me who makes it random.
Output of 5 evaluations:
```
93 28 25 6 25
```
PS: the free running us timer is normally used for profiling...
A *much* better random gen would be:
```
'/dev/random' asFilename readStream nextByte/2.55
```
[Answer]
# bash — ~~108~~ 106 bytes
```
ls -al|tee -a X|grep -o [0-9]|xargs -n3|sed 's/ //g'|sort -u|awk 'BEGIN{X=0}{X=xor(X,$0)}END{print X%101}'
```
Gets a set of all three-digit triplets from a detailed listing, exclusive ORs them with each other, then prints a result modulus 101 to get [0, 100].
Depending on the activity in the directory, may be random-ish, or dynamic but predictable, but should never be static. Running it 1000 times, I was surprised that there didn't seem to be any patterns.
Sample output:
```
$ ls -al|tee -a X|grep -o [0-9]|xargs -n3|sed 's/ //g'|sort -u|awk 'BEGIN{X=0}{X=xor(X,$0)}END{print X%101}'
37
$ ls -al|tee -a X|grep -o [0-9]|xargs -n3|sed 's/ //g'|sort -u|awk 'BEGIN{X=0}{X=xor(X,$0)}END{print X%101}'
95
$ ls -al|tee -a X|grep -o [0-9]|xargs -n3|sed 's/ //g'|sort -u|awk 'BEGIN{X=0}{X=xor(X,$0)}END{print X%101}'
62
$ ls -al|tee -a X|grep -o [0-9]|xargs -n3|sed 's/ //g'|sort -u|awk 'BEGIN{X=0}{X=xor(X,$0)}END{print X%101}'
6
$ ls -al|tee -a X|grep -o [0-9]|xargs -n3|sed 's/ //g'|sort -u|awk 'BEGIN{X=0}{X=xor(X,$0)}END{print X%101}'
51
```
[Answer]
## CMD / Batch - 14 Bytes
```
echo %time:~9%
```
Grabs milliseconds off the end of the variable `%time%`.
Add `@` before the command to make it only output the number.
```
C:\>echo %time:~9%
40
C:\>echo %time:~9%
53
C:\>echo %time:~9%
19
C:\>echo %time:~9%
73
C:\>echo %time:~9%
25
```
] |
[Question]
[
Write a program or function that takes two numbers - `x>3` and `n>0` - as input, and finds all possible bases `b` where the digit `3` appears at least `n` times in `(x in base b)`.
Input and output may be through command line or function arguments, stdin/stdout, graphical input/output, error messages, function returns, etc.
The code must consist entirely of three-symbol "words", where each symbol is a letter or number (in printable ASCII) and the words are each separated by one non-alphanumeric printable ASCII character or newline (see example). Furthermore, adding a space into any of the words must ruin the program.
Shortest code wins.
# Example
The following code meets the first part of the specs (but doesn't actually work):
```
abc 123 fwe[3gY]4fs-es3=13N
338 w3W|W2w
```
# Test Cases
`5 1` ->
`8 1` -> `5`
`23 1` -> `4 5 6 7 10 20`
`15 2` -> `4`
`111 2` -> `4 6 9 36`
`819 3` -> `4 16`
A test program written in Java 8 can be found at <http://pastebin.com/E8GpHbfB>.
[Answer]
# BBC Basic, 207 bytes
BBC Basic allows you to abbreviate keywords by ending them with a period (e.g., `PRINT` ↠ `PRI.`, `REPEAT` ↠ `REP.`). I should really be using a named procedure here instead of a function declaration, but abbreviating `DEF PROC_whatever` to `DEF PRO.` just isn't going to work.
The rules make it impossible to use an `IF` statement, so instead I'm calculating the target line of a `GOTO` statement based on the result of a comparison. (In BBC Basic, `true` has a value of –1, so `101-ZIP` is equal to 102 if `ZIP` is true, and 101 otherwise.)
The last line (`103=000`) ends the function definition and returns a value of zero.
Tested on [BeebEm3](http://en.wikipedia.org/wiki/BeebEm). Lines 10–60 are excluded from the byte count.
```
10 READ X,N : IF X=0 THEN END
20 PRINT "x=";X;", n=";N
30 A = FNX(X,N)
40 GOTO 10
50 DATA 5,1,8,1,23,1,15,2,111,2,819,3,0,0
60 REM -------------------
100 DEF FNX(FOO,BAR)BAZ=004:REP.BAT=000:QUX=FOO:REP.XXD=QUX MOD BAZ:ZAP=XXD=003:BAT=BAT-ZAP:QUX=QUX-XXD:QUX=QUX/BAZ:UNT.QUX=000:ZIP=BAT<BAR:ZIP=101-ZIP:GOT.ZIP
101 PRI.BAZ
102 BAZ=BAZ+001:UNT.BAZ=FOO
103=000
```
[Answer]
# CJam, 108 bytes
```
097{sLo,Lso=rii*rii:MLo;Lso_Lso,002>Lso{001$Lso\Lob{003=Lso}Lso,Lso,MLo(Lso>Lso}Lso,Lso\Lso;LoS*Lso}000$001*
```
It will not stop people using CJam...
[Answer]
# Haskell, 219
```
003&bbb=001
nnn&bbb|bbb>nnn=000|000<111=mod nnn bbb&bbb+div nnn bbb&bbb
nnn%xxx=ggo nnn 004 xxx
ggo nnn bbb xxx|bbb>nnn=get[nnn]nnn|nnn&bbb>xxx-001=bbb:ggo nnn(bbb+001)xxx|000<111=ggo nnn(bbb+001)xxx
get(xxx:sss)bbb=sss
```
call like `8 % 1`.
I mostly just used three-letter / operator names, but it was tricky to get an empty list (`[]`).
[Answer]
# C - 252 characters
Will admit `C` is not the best language for this, and had to cheat a little bit...
To compile, save as `fit.c` then `gcc -D___=/**/ -o fit fit.c`
The function `fit` can be all concatenated on one line, but I thought it looked nicer and fit in with the *threeness* of the challenge by formatting in lines of 9 (=3×3) token/punctuation pairs. The hardest part was figuring out a way to check for `== 3` without using `==`!
```
// The function I'm counting...
fit(int not,int fin,int*rot)___{int
nor,fir,nit,ton,tin,ion;for(nor=004;
nor<not;nor=nor+001)___{for(nit=not,
fir=000;nit>000;nit=nit/nor)tin=nit%
nor,ion=tin<003|tin>003,ion=ion?000:
001,fir=fir+ion;ton=fir<fin,ton=ton?
000:001;rot[nor]___=ton;___}___ ___}
// This is the code to call the function...
#include <stdio.h>
main()
{
int a[999];
int X[6] = {5, 8, 23, 15, 111, 819};
int N[6] = {1, 1, 1, 2, 2, 3};
int i, j;
for (i = 0; i < 6; i++)
{
fit(X[i], N[i], a);
printf("%d %d ->", X[i], N[i]);
for (j = 4; j < X[i]; j++)
if (a[j]) printf(" %d", j);
printf("\n");
}
return 0;
}
```
Output is per specs:
```
5 1 ->
8 1 -> 5
23 1 -> 4 5 6 7 10 20
15 2 -> 4
111 2 -> 4 6 9 36
819 3 -> 4 16
```
] |
[Question]
[
**Input**: from STDIN number of vertices in Graph \$2 \leq N \leq 100\$.
**Rules**: [Code size] = max ([code length without spaces, tabs and newlines], [total code length divided by 4])
**Math formulation**: In the graph of N vertices, between each pair of vertices can be 3 road states:
* there is no road
* there is a road from A to B
* there is a road from B to A
**Find the number of different graphs on given vertices.**
We can apply next formula (number of different road states in pow of pairs number): $$\huge3 ^ {\frac{n(n - 1)}{2}}$$.
# My [Python 3](https://docs.python.org/3/) 37 bytes solution here:
```
n = int(input())
print(3 ** ((n ** 2 - n) // 2))
```
I know that exists **34 bytes** solution. Then I started to think about 1 liner, and find next formula for sum of arithmetic progression, which use N only once:
$$\frac{(2n - 1) ^ 2}{8} - \frac18$$
Unfortunately the code only increased:
```
x = 2 * int(input()) - 1
print(3 ** ((x ** 2 - 1) // 8))
```
[Answer]
# [Python 3](https://docs.python.org/3/), 34 bytes
```
print(3**sum(range(int(input()))))
```
**[Try it online!](https://tio.run/##K6gsycjPM/7/v6AoM69Ew1hLq7g0V6MoMS89VQMkkJlXUFqioQkC//8bGgAA "Python 3 – Try It Online")**
In Python 2 this is just `print 3**sum(range(input()))` for 28.
[Answer]
# [Python 3](https://docs.python.org/3/), 34 bytes (not counting the newline)
Uses the conventional formula for the sum of the arithmetic progression (\$\frac{n(n-1)}2\$) and the trick that `n-1` = `~-n` (but with higher operator precedence). This way, one pair of parentheses can be omitted.
```
n=int(input())
print(3**(n*~-n//2))
```
[Try it online!](https://tio.run/##K6gsycjPM/7/P882M69EIzOvoLREQ1OTq6AIxDXW0tLI06rTzdPXN9LU/P/fFAA "Python 3 – Try It Online")
] |
[Question]
[
## Background
Sometimes, people think you didn't work at your git project. But - you can prove yourself with `git shortlog -n`. Now, the problem is you are a programmer and programmers are lazy. So you want to write a program which shows the person who committed at most.
## Rules
You may not do the following things:
* use `git shortlog` with the argument `-s`
* use any alias, which calls git on any way
You may assume the following:
* git is installed on the system
* You are in the working directory of the repository where to find out the person
* The output of `git shortlog -n` will be piped in your program, but you may also call the command in your program, even though I can't see the advantage.
* If there is a language-specific package or library for git, you may use it.
## The output
Your program has to output the name of the person with the most commits in the repo.
This is a [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") challenge, so the program with the least amount of bytes wins!
[Answer]
# [Bash](https://www.gnu.org/software/bash/), 20 bytes
```
head -1|cut -d\( -f1
```
[Try it online!](https://tio.run/##rVjBbhs3EL37Kwg0he0mUuIALYrcXMdxDMSxYTltDwEKape7Yr1LsiQ3sop@Wm/9MPcNubviriQnbZxDkEjkcObNmzczmnO3uL9fCJ6zydFfWePZJP94wCbF0f39BbdeKvbTP397r4RlB0cvXxy@2mPhz7mSXvKKZbqupW8/PM5zNudOZsxY/bvIus8/mJx7wa5Pj19fnE7rPDluRSnumDZeauUYVzkrrTCs1rlw7bELYUvB5parbMH2a@68sPtMF6yUftHMp3DhVT1vRPDyuRVwmicvOFNJHwwOnjUVz8T440vEclobv2JFxUvm9fbbldYmnii03WXL42u3grM1E3e8NlX65byRVU72rdae5dICLG1X7YkTKwivd@cnp@9nI8BynTW1UJ4TYmRhjOqF/iS6F13/RKGrXNivR/Ra1NG@x22hG9c9BSYY2edsR8ZP7wAVOPVyskbnGeM9IPi/CZh2/k8fhwNwFgmKLAuYbabsjbyDEyVbwiBSmulSSSdVue0smbxuEPPR0YvO1WnyHRCyFTfJgxfcw/GRiYkI5QPSTyqpRGDUCMBBthNP/croxJKxUnly9oEXI4SmqSqE90cjnGffwP3C6ppdWV1aXr@5/PW5rSe@NsNsI0tIiyQ@hePTzFGBPwabCk7Eh@vP2BX0hp3v/uY8CbhuKi8dSCS68iOU0qqHt8oneHDEnarKDobenL9jfK4hhK/hAV75mVeNOPbeynnjxSNJEqKqxIQQbT3sVRWGapFLci2EB010XTDzFcujU9MxFJOIBQmTm7Jfzq8@r7zZgqtSVLp8nJhkqbQVMAuMW7UJlWyEdVqhUzSuQ@@DksWKSYq1CHVZQAGLQlgKMkbdGa4qvWS1vAvcLoZftuR8R2JMjeMmKXKA8JRJxxSuu4W2PvhycDjt7y61vWVOoPq8zBwZn6WUCcoZzswRMWIJuhDw3QZtcODk7fH7s9N3l2ejEyOlGLrvdC0iaHmDXpNFXY8UbD0ayQbiVA5dSdieJSHl7CDXwql9T1C3jXUl/GGXX34rRndDfK3g4fQXB3YSqDMyBj4hAQRVVnHnPldoQZZJhFwDCyE91@TEtNXblOEgVjjrEgVsNdYQM2rSuv7BGSIChZE/pdVkXunslg5JZZrNQaWA7EUukAdKLHu9l5SrsfYGEIczS7h8M2wlaB2E6dJSaKDWtsg6GYdjLTiJc08UEy7jRoQGvlY49Ew4dLe1ZNtj@0Pcx7kLEUxc8Jf5hegkJSSaOvGkDnKZLaT4FE9oY7STvfjtMBz6kKwyq5dRtJq589JDNF3AllpcIUTuHjbzVvsCyNCNC630w4ffI19znt06MG6RiL1rjLHCOWr8sqLsd6@vJchH@t1MhoqDKIgFG2wmszeTJMvXbXrjhz18NpSGBXbW8Sqxuq/31zbYciGRM6mcsN5FlPGXhSL5h0MeVifBNPAqKDs3vrGkKg0YE@BoU0HwDBjUzsIQ8zV0u84G5jz55mlgfPrZx1ArK9btBjOSNMDvbZPBEYKf/KQgB9YNt66fSQPrp2rb@@F2FxQUsfSLtPHUJJtI51ws@Cepm9h3nny3A8eQqUHB7VCoM4FGxyvp2r5K6JRWNybuKX15mz4YRPr1zZR0ITQFTKOOuqTVeZOhs0InCELQ0W@uXWizcYhs3fk2XVckzsYijFNhYHy6LoQTiLKEIiLKy3QdW6Pg0ONlgRalfLVKvI3KWUInO1N9NRniBdVTfAG2@8Ki2JIplSRjKapq7DfdOaOVkJw5RrM@6/bDzQipvJKeRDhsO7hjA@gKehZWvjhQdVU9iOqa1uUKfxGz/xRWt1OaAAeISIPDba@MD2/U3m/B5whAYHkvO5bGg4GArOVNk62WimEgn/VbKkOTwDbZ52cHt8dF8SXfdNI40zbsGgMW/X@@79C5sI9ZfStU1OmMuzSRuV0x26gOlFGxj2fbdpZvOzcB7Wgm3FB@qLYKOdf0hITzA/nfvFCv6ynJD@JrLHxTIH@jJJat0YjSQRkvYgoQr@BjNwCKpLtRTU/4klvxgDJf91qbhr7X/oBzqvLw680P/Y83hG3N7W2ul4qqcPsqMFwVv/8xUg0I5cJjOKieG4ppcjSEHg7funZq0WmXCPM@ujKR28cPMJBFtBsf/okysmXYd0kcwCHUGThE/YYIF38mAaZhZEXIgtcbZRbbPDnwUVG@uc0rmgRgBxXvkfu6vXJFS3OwRbP2xqTgkn1rVExRO2aUvBsCh0ZN5Ip42jY7pHt4h4rmP10YCdmX3e2G6g2xX0/O2EUURl5WINyttxL5c@MD8cSmHG8/HQ4ntN48Fvrc@myQtG7vPYibUWNpLUTSc02rjUE1Ho4txFF@bSeuaXvrXzXA/p78ce/Kd/6osUcakJynabSdtmhc/xc "Bash – Try It Online")
[Answer]
# [Bash](https://www.gnu.org/software/bash/), 18 bytes
```
sed -n 1s/.\(.*//p
```
[Try it online!](https://tio.run/##vVvZciO5sX3XVyBiHkTZTamppaf70uEIDbXOaBtRbb/cF7AKJGEVCzUASlT5w/wD98PmZmKrAlhsqccO90OHhMKSyPVkJjSjavn774rlZFiSkTrY/9/B/p8ODqrffz9jZckVGRyNjvb@Z4eYfyteCkn0mtFnMoefFC3zmXiNvmZLWi6YIloQzV41lYwqN4HmORw0LcV6Rcto7JkXBVFrrrNlNF7AXjVdMMLLnL2O3RE0/0et9IqV2u/MV5UUL7CAl5lk@IUWRNS6qvVBzmb1YsHLhZ9bcs3hcyZWK66/e7Cq1RIpYwuaNWTOC7gr8uLlkMxo9szK/Hsn1tVCUrzty@GuImfnFzenT@d4pcLeRHPhuTXnrzAP79MQWvKV@UYGt1Nyni/YXp8g3FjJ1oGbY/cN2aWZrCSD/987b9wSEYlKr0VYqMZEsqqgGYyLkvUc811rWjouhxWTK1rw8jna6Ki7TV3lVMPgFVXPrCjcRKtdeKggP0/v71rdKrjS//FJlq6Tli43DtppFNWpxbuWgt6LnM85jI7IWtKqSvh4KalSHeFrlA7KKaW4VgwUQ@QMaf/6NBn3bOCP72rC@79NlrzaNhBUGkVsjJNkNFt2TPPfnqAlLVUlFDeGwaQUMacKnrFSsWB5VlNKumJEzAk4q5IS9sqyWtNZwWJlXUrGukKxdqAbOO5bE5OzJJsDWeBVUIm7m3j5GfVQAijSoMDgM6RYwZ7MUYd@FX6JXcgfWuQpuuFFk6hVzlA/8WMmgNmlhhFQG@CzUXr6QqeZ5JUet57X8BpNWEjdysNyZMWVwrWeJ8EW8jpjJFtwu1qB0ZOl1hXISSw840xsyGiZgS0j/@oSFv5WM6U3bMob00CxxZzWhVZ7759iScW7kS89Q@Owx2kFKsfIBKKCKB2rswIMqKI6Dl@3HH10MTw8@/awVQIMMxBQ0djZhnv9WkIgzTeUcmPYe8o5yM2Em9OHG5JDFGOZjtX0uve34GnOGgpCMMtj3VgJyQhKGU8FoqsGRQuS69If7S1@6f81nAUyLcExKaNTgDmM0raiW0uhWTIpjZ13fOWZWbBXjqQlGom2JpUmL0wqdA5agC1EhP3E6BsD019vuGZvDU2MDIrUCjaGTYgrEWDYUN1LIRk4q93bsiqxZl6C1C0wGIOPAeACg2ue6yV6OAiwICkEZsky4J@XM4RbUCocnNNn4DvIFDQ8Zy/gO5NVboVRtFZhvmdSCE0PYg3XXoKRo4sp4QIvAAJWGwFmLeQzlaIuc7Ph9TkZjcZRTMbgZN3e18ebeK2ajxEiFjX@tr@AKLEoUZ15afTkj0y2touwBJ2ccQhAFiyONgM3OueLWlrA1oLBWJvt3JwZx9S3JtUnXm4d8dzfnHVQK3lQiIwWBzNUBuFxPOk4MGTi6cN17292m4fmmW0b6MZpxYo5aBy4a2K9A7BQ16XxHhWVEHpBnxHjcJXte@DCVM9OL1Rys0zzFYPwv7nI8BT8ENzLhNooTATcaugAp7AU4DyqZZMmEYFiJ56Yx6LMQzJgt3xowLj6cJmd28JXo@NTo@Pd6B8w7YbXPy2qZZ09vzk2bVZq20AFkQnsQdLGJGXByBUDPwNu5FscB1ZWoHdguwUNAZkZ2aUfDetHRxu45/tmO74BsaLcPuRIHpO8AejGMw9sOgYfA2BvhDZAAasB7lU6WOvJFjr@vQVULmqTpJolD0wW5ARRBKLNDhLBj0j/mspcGTaBwc94wXXzX9v78f/@ldOtI6rC1KEKbsKEhzYp7SrMLqK1XWuGkKND3LCeGPKOF1S6TgXBuoMe7UuM8K0PFpS5bAAMLccIi79jvIsrFC7ZKZpqKQABLtEH0DayvvE5xBg3A4xp8nB89OP7Pnt/7BI/TMLaVHUr2HIIdFjPmjdGnmh2v23AI1f2mjEIUhBY10vABQBYMxPOkKXDDkszCK@6S9TXkpuskSrIGi@Gn6ODLrhkMxoS7d5BVYHOdVM2k@ALQKYSgKmQTSeT0JKvVi1KchmSdfkENLk0YM6zzh@UMM5eGc3GqiHeAjExLASfnBOaZTy3daIYR3kbUhp9igEUU/ujZ44DR97nhCsYrQe72AekGtMO2R2yOcQvPMGrhWLkFsIuz1wmccn1VT1zX5dAI7l6ur2x36wVuWSpx/oKQZEuMP8MbQDp6ZqfX5JzZX2yk8esnkNOGiXRFZleX17fPZk9IEpmbF4XoD88DoZ/56pN5lzxxvFlX8uGa1Giu9ovGUiOQ5R07DmAnG@I4AO5crhtS42gCpAg66Z/LqYHooomMbC34ZM1Bk9CRwUVkDm5f5ySJSRVwGhD8prNHP@Sg2Z88U@AD8K45OckgrGmSCPY5tBP97fWfwdcAB6SyQQqOMWOD7ioQcY62S8ZNOpQ8JmkqJzwrQ1gyUyHYzbO7CjpohCgWZiz1R683lJgCg9QJKPg/wgqDTr2p/PHWwuVrcA@OJO0kvhg03qwePRIXe8vpHfyxiO1afcIBkGmKOCCNt2t/SUYnm8ClzUXyQpG1duhxeOqNr/ZHFkwSD5RFX@rwZGZzEwRzNHAk2UFxxKJ4iHv7RYpkFJffFmYxGUTj4L9ZZijGm82hxCLHLw@j6g5M24ojSY99UOU1qNFrnC20qDLGArBAWvwPY9xrYoLQOCk1gYTmGMzIeU@UQ0sXOVG84ELRmo99U8xn3NIJBxxm0kU7O/tB3ehRnwVuAcG@mcqm7ZWDWcyq54xjIW9E1xyf/8QT1mCTD1l6AxtSSG@WLTifrlKadQSokTvZPiomjJLvlnRuVCOwlauHGY/2MqD867AenRFaIhxfM6KTYiMCG@4ATcfIdh/cHtbyWNMaW9dADd9/Y@9VsBJT4RKL7MUqJLuNp2Se2CCd9PY/BhbpNayIdrtChyFIH8XsshttoSktrfydotVvjKnpe6WJtJg63KRZ9YEiisQJSKd6f3dDbfFLFir@4vBuxmYutwNIBlJ2QXBDB0A3E3spk3xsDSKZQ5eorCM3wjYfv8fqkOqvU5d1srIKk@LIb38uKeKh7grCNbmaQGBjaAgTN3ZlmotwzsWjCm3sq2ybl5eQIiCyblsUO3MMSuIdhxYYWN9nO36YGhhwCCsbItrqkKfaqR@9fT0QA4/Hln4bkAawMS0wAT5OiXwI0XH1ud/TCYLbM1qMGosHQeA1PFGS9TV9sugjT173ej1ALjzhqtqVyEgAzWSIaIl6SH4KxpD0Luni58n7zUxzOGDrFGZSpvzwGw@N6WABsDi6zjVg65fBIatDE6CNDQ2vEdbQ/tJUrCBNnk3sCLmIcaUmQBhwHyYrJI6eslv45LW1HMFMOLg9gZC@t74Wzn3zc3fbsn1Y48Jmd4QwGLE/ooMIFaCmKzzylil93yvKJNNBdKNpYCSRRA@ASCLRUsLV0Utk5D6S8F4a1EzIfDkp@v7FgWG3L6vi2k3iaEMrSG6lhrCkG2GWsHsxdt14L1zeMYiMl0Eh1cJUWxdFMm829INK3iRe3TrTJoBc2koDbtKolll7B7zLmzuQogrGrOBdoVBNFOzYZyYjn/4cwxPbi7vb8inz@SSlZy9V9E3M8fThSjjEZP6TlLY5KkKTDHoyopvgN6ZSbiIFWZoRXvfZKXp9uq27l0yEnc/kFDjIaq2W2QdmqorrOebGU4OoXwGnHsZpR2fOWRrtTQNT9ihU2HbSpFkayGRDYGCDz29vhSB2WBhwJ4T/Ie2wdHx2MJ4d72koc6fEDxZgvawIWRODShIPcNIKAV4YzIwryD2l3oVnGRUOjQXHEzpHPLMPW9AqS7bm6yoXGD6pVTN0OWsMdEEEMNY4nLOWIa9Kp@PCo1nuETXKn1aszRObiEKXwBnKqMVw6SSm8qMqToYVOwxdW5S3E7sq8vfONBlEnRkoPT5hnzOxbqM8i0fKyeX1w6FEaxt26TP0mlZ39@AN2WNwR17rSEnwacZEN2iTgs@QTCGWis7uRPEXO/ZpYuxUeX5n2NzVTpp2l@AHsukwWTDEBlFg/L5TVO0kZQslhlESgc8sXLxdHb@GCP@69IWPuIocvd1@pCUrldgzxlPYqoUEJzUvn5N1tdyThNXryVH0yiofLdroi8x2J/UM@seo1FaNmlld7JkbVBtk4BeREYh31zNimZIU1POkuOsfreKpWLHPk51yXpvAz@t01HjKMJOr06Hhyefgv9ZSFvbQKBld4bARv3Mk9GhEWG0yGkJRDHInL0PAKGwuLY2a3z6SZZUgefwJZ@9jtUgPt4Nt@k1Fp@iIh/QJ8YafFWrpA1B8@FFQePBJ8hUpt0@yjfQycbcOSAe84wKueoXRleVbNj/VArcTadIhP6mLl30wDtJsVadkpgod3UfJ5Eq4JBujA8IXrSDEHuzBQdUqFolfXkYaVfsmkpg58mSZyAYcaq7vX2NHme2ze@nR0SE/lrT/NHwGH@apolNKuc7Frrtfk7/DlZ/Tn2zYozuVZsnSJ1OhGvRqx4nt5FzTh8S@FuBM5O3ooTM8VsPbd7rgvBmH0wd0Ph6DP7GCH@aTONmzK91BzHYa3bq5RN8DsKz9OUElvaMZ61LvHdlXzbC/lcJ1nFmju@YZKJTD1RhwWVw8TAJkPz8FQLJJC6jstlUABTXvmic4OIu7sEbAmyboMKPfXMGW4VYuTGbBExQawEp9UvstTiY0iYEuGqrVV2Rrjea2BUrYncDC4ezWmtMhQBc7EAmosng@CS8Q7XPJKJnma42GI3pJZfJkK9cvNIN0Dv5ma7SCpetyJ8/ITce7qdPSZ/ePSx1GhRdgr26VxqbteG/QU7dtE1hPBcUs31e1e2wJM3YVmlpa1OJvRsjVLpBTB0lT/a3TtI9Y3NsxmPIs0940leagQ@GZPtSYM4MRP82vJzcnOIXIM7UpPqoWdHcF10s@2jh9@yb7t4Js2YmMNs1GUpW67eXXE7j/sINnTUSruoLKnYlaKdc0jpWREudFotFYQOBq85GCUTfyXb58cfjbhvHFZg4Q8zchMrMQGLtS7sdQq/RFcRaY7RRaWzfT/TlxkFYLn4Z3Q2tHtgBX4phVhGHKMjRtzSz@98xhmpFH7MVJAf9mx131SuNSY9M8zKGflWRBM6VKIVtWGIbL3Y39QzuCPZgVP/29Ommjag/s80OkZ3hHsMcHJhVUya5qFXCnW62qZrVTBTg1IGVuEPS7jSPf8ih2exRgH3F2A@uIW1fNQFRo4/RQ9@tRY/NJwfgDJp@KTjl6XtADFpR6qFtvUevQe3S3lfXHYa7JNzUwqLntfYDZGgmQetixaAwcAK3kRZP3/KMLXlzv3Na5pCPA2p54WXzDEj28DCEga@2FP54fnp2e76/yv@Twy4m/ED278D9T8Do3voQniL2r9hEB9/z2bwv5XNf5AL/sdkHcKVG9sgW7DUZkz1jr1sHfFn@4n5yeoP6bn4YfvrywYQz6056UXfoyrsFbvhJNj7CYNJjAp3rjen2TwC6AHqFNXlXvG9DbJKNxsXMkMahO4UrsDXoERZlsWOZzAkyMrrYFp/D327oyF9h9nAAJBz8JWjz9dlfd3bsH8ncGsdbACgbtRjluu@PRywCTDvjna7Zeye4QuP7P2zryv@Ria4UwLBAbd4Z2OeMGG9wKO6W35pdK8jBQkr6w8hOrgBIFg1tDirsHA9HyUt920UALA5JFhZdZN3TIXxzGkiwopL5P70xl3SfTvOc7CLFQ0vxwa57zG1ERnYzlh0eZ4cjxo6/HH08/PwlYx/p/NNo9Pnz5/mPnxjL6I@Uzk92u/uZuvKWDUf50adPh7OTeTb7eHSY0/zoy2f28SQbUfpx9iWb/fjlEzum7PNuJJEOhUZbuycYsUCWICQHF7pDZ7LO/wlOMqghJvoeaoQ34eWiHNI2woqqcf3e8ETFQI4fyKB1S3vGF6Mt/EIVE3IB2h5Ocam8/5Mb2x3bWYK0qS4gLnem2kDRNvNsiwFfvBeQasAdvFZ0Fzkn3WIPDKQ7OwguZyJvRodHx93psWqY@4XaoWn2PEwud3b@Hw "Bash – Try It Online")
# [sed](https://www.gnu.org/software/sed/), 11 bytes
Run with `-n` (counted as +1 byte).
```
1s/ (.*//p
```
[Try it online!](https://tio.run/##vVtZcxs5kn7Xr6iIfpC0Y0qmDre93NgINXV2U0eL8swzWAWSGBWBagAlquaHzR/Y/7XeTFxVAIuW3DOxfnBIKByJPL/MhBQtvn0bqsNs7@A/Dg@rb9/OKedMZXvHw@P9/9zJzL8V40Jmek3JczaHnxThxUy8Rl/zJeELqjItMk1fNZGUKDeBFAUtsikX6xXh0dgzK8tMrZnOl9F4CXvVZEEzxgv6OnJHkOLvtdIryrXfma0qKV5gAeO5pPiFlJmodVXrw4LO6sWC8YWfy5lm8DkXqxXTPzxY1WqJlNEFyZtszkq4K/Li5SibkfyZ8uJHJ9bVQhK87cvRrsrOLy4nZ08XeKXS3kQz4bk1Z68wD@/TZISzlfmW7d1Os4tiQff7BOHGOF0Hbo7cN2SXprKSFP5/77xRS0QkKr0WYaEaZZJWJclhXHDac8wPrWnpuBpUVK5IyfhztNFxd5u6KoiGwWuinmlZuolWu/BQkf06vb9rdatkSv/bJ1m6Tlu63Dhop1FUpxbvWgp6Lwo2ZzA6zNaSVFXCxytJlOoIX6N0UE4pxbWioBiioEj716fxqGcDf3xXE97/bbxk1baBoNIoYmOcWU7yZcc0/@UJWhKuKqGYMQwqpYg5VbKcckWD5VlN4WRFMzHPwFlxktFXmteazEoaK@tSUtoVirUD3cBx35uYnCXpHMgCr4JK3N3Ey8@ohxJAkQYFBp8hxQr2pI469KvwS@xC/tQiT9GElU2iVgVF/cSPuQBmcw0joDbAZ6P05IVMc8kqPWo9r@E1mrCQupWH5ciKKYVrPU@CLRR1TrN8wexqBUafLbWuQE5i4RlnYkNOeA62jPyrOSz8o6ZKb9iUN6Y9RRdzUpda7b9/iiUV75Z96RkahT3OKlA5mo0hKgjuWJ2XYEAV0XH4umXoo8vB0fn3h60SYJiBgIrGTjfc61cOgbTYUMqNYe8p5yA3E27OHiZZAVGM5jpW05ve34KnOW8ICMEsj3VjJSTNUMp4KhBdNShakFyX/mhv8Vv/r@EskCkHx6SMTgHmMErbim4thabJpDR23rGVZ2ZJXxmSlmgk2ppUOnuhUqFz0AJsISLsF0reGJj@PmGavjU0NjIoUyvYGDYhjiPAsKG6l8Jsz1nt/pZViTUzDlK3wGAEPgaACwyuWaGX6OEgwIKkEJgly4B/Xs4QbkGpcHBOnoHvIFPQ8IK@gO9MVrkVRtFahfmRSSE0PYg1XHsJRo4uhsMFXgAErDYCzFrIZyJFzQuz4c1FNhyOopiMwcm6va@Pk3itmo8QIpY1/nawgCix4KjOjBs9@TOTre0iLEEnZxwCkAWLo83Ajc7ZopYWsLVgMNZmO7egxjH1rUn1ifGtI577m7MOayUPS5GT8nCGyiA8js86DgyZePZw0/ub3eaheabbBrpxWtFyDhoH7jqz3gFYqGtuvEdFJIRe0GfEOEzlBx64UNWz0wuRzCzTbEUh/G8uMjwFPwT3MqE2ChMBtxo6wCksBTiPatmkSUSg2Ikn5rHgRUgG7JYPDRhXHy6zc1v4anR8anS8G/0Dpt3w@mdltazz5zfHps1KbRuoIDKBPUjSmKQsGLmi4GfAjXyP48DKCvQObLckISBTI7v0o2H98HgD9/zYbMc3IFbw7UOO5FFWNADdWO6BTcfgYwDsjdAGKGA1wL1KB2s93ULHv7aAyEVtklSz5IHKMjtFFIFos4NE8CPSvyayUIZNYPAzVjLd/L/t/fg//yzI1hFVYepQBTdhwkOblHYVZhfR2q41Q8jRIW5YTwx5xwsqXaeCYN1Bj/YlRvjWBwvKXDYAhlZghMXfMd7FFQqX7JRNtRSAAJfoA0gbWd/4HGKMmwHGNH44Of75fZ@9P3aJHyZhbaq6FWw5BDqoZ80bI08kv9824JErfc0pBCkIrOsl4AIArLkJZ8jSQYelOYRX3SXqK2cmayQKssbLwefooEsm6YyERLt3UFWgc92UzST4ApCpBGAqZNPJJLRkq1WLklyGZF1@BprMDZjzrPMHJYyzV0azsWqIt0BMDAvBJxcZyXNW2DpRjKO8DSmNPsUAiqn90TPHgSPvc8IVjNaDXRwAUo1ph@wO2RziF57g1ULR7BbCLstdJnHF9HU9c1@XQGN2/XQ7sd@sFblkqcf6SkGQLjD/HG0A6eman19SMGV9spPHrJ5DThol0VU2vbm6uXsye0CUzOm8LkF/WBwM/8ZUm8y54o3jy4GWDdOCo7s64BQkxyBKOvYcQs43QPCBXDnatqVGUAVIkHbTPxfTA1FlkxjY2/DJGoMnoaOCCsgc3z9OsyUkVcBoQ/Kazhz/koNmbPEPgA/CuOTnJILRpkwj2ObQL/e31n8HXAAeksoEKjjFjg@4rEHGOtkvGTTqULKZJKic8K0NYMlMh2M2zuwo6aIUoFmYs9UevN4SYAoLUCQn4P8yVBp07E8Xj7cWKluBfXAmaSXxwab1YPHokbreX0jv5I1HatPuIQyCTFHAJWm6W/tLUDzfBC5rLpKWlKi3Q4vHVW1@szmyoJB8oir@UYMjM5mZyjBHA0@WlwxLJIqFvLdbpEBKffFlYRKXTTwK9pdjjmq82RxCLHLw5iKi5ty4oTSa9NQPUVqPFrnC2UqDLmMoBAeswfc8xrUqJgCBZ7U2mMAcmwspDzLVwMJVYTQfuGCk1lP/FPM5g0TCEbeZRMH@3n5wF2LEV4F7oKB/prJpa9VwJrXqGcNY2DvBJff3D/GUJcjUU4bO0JYU4otFK@6Xq5RGLSFK9E6Gj6rhefLNis6FchS2cuUw@8FWHpx3BdajK0JDjONzXm5CZER4gw24@QjB/oPb20oeY0p76xK46et/9LUCTnoiVHqZpUCVdLfplNwDE7ybxubHyCK1lg3RbtfgKET2NyHLwmZLSGp7K2@3WOXjBeG6W5pIg63LRZ5pEyiuQJSIdKb3dxNmi1mwVvcXg3dzMHW5G0AykrILghk4ALib2E2b4mFpFMscjKOwjN8I2P7g76pDqr1OzcG@CoPfkj17@XFPFAtxV2RYmyclBLYMBWHqzrZUaxnesWBMuZVtlXXz8hJCFEwuZINqZ45ZQbRjwAob6@Ns1wdDCwP2wsq2uKYq9KlG6tdPTw/Z0cdjC98NSAOYmBaYIF8nGfxI0LH1@R@TyQJb8xqMGkvHASB1vNESdbX9stfGnv1u9HoA3DlhqtpVCMhAjWSIaEl6CP6KxBD07uny1/F7TQxz@CBrVCZucx6YzeamFNAAWHwdpXrQ9YvAsJXBSZCGxob3aGtov0gCNtAm7wZWxDzEmDITIAyYD5NVUkfn7DYuaU09VwAj7t1OIKTvj76Xc08mf73Nbh57TMj0hgAWI/ZX2R7EShCTdV45rfS@7xXlsqlAurEUULIIwscAZLFoaeGqqGUSUn8rKWstaiYEnvx0c9@iwJDb93Ux7SYxlCE1RFeuIQzZZqgVzH68XQfeO4dnLCLXZXB4lRDl1kWRzLst3bCClYVHt86kKTCXhNKwqySaVcbuMe/C5i6EuLIxG2hXGEQzNRvGienop7/E8GRydT/JPn3Orihn9L2Kvpk5ni0Ej0dM6jtOYZOnKjDFoCsrvj30zlTCRawwQyva@yYrTbdXt3XvkpG4@4GEGg9Rtd0i69BUXWE938xwcgjlM@DcyzDt@MwhW6ulaXjCDp0K21aKJF0LiWwIFHzo6fWlCMwGCwP2nOA/tA2OjscWxrvrJQl1/oTg8RK0hw4gc2pAQeoZRkIpwBtne@YVxMFSr4KTjEqH5oJ7UzKHPHPfG1Cqy/YmKyIXmH4pVVN0OWtMNAHEUJq4nHOaY6/K56NC4xku0bVKn9YsjZNbiNIXwKnKSUUxqWSmMmOqDgYVe0xdmBS3E/tq/gcDukyCjgyUPt@Qz4VY8yjf8rFyfHXjUFiGtW2b9Fk6Lev7G/CmrLF3R19ryEnwaQZEt6jTgk8QjKHWyk7uBDHXe3bpYmxURfGX2FyVTpr2l6DHMmkw2TCUDaNB@fymKdpImi2WOURKBzyxcvF0fvEYI/4bbgsfcRS5@zp9SErXK7DnnCUxVQoITupAvybrazkniavXkqFplES@2zWRlxjsj@uZdY/RKOFNWtkdL2kbVNskoBeREcg3V7OyGZDUlPPkOKvfrWKp2LGPUl2y3tvAT@t01CiKsNPrs8HR6afgfxbS1jYQaNmdIbARP/N0eGREGC1yWgJRDDJn7wNAKDSurc0an35mS6LAc/iSz37HahAf74bb9BqLT1GRD@gTYw2@rlXShiDF4LIk8eATZCrTbh/lO@hkY@4cEI95RoVc9Qujq0o66H8qBe6mUyRCf1NzFz3wTlKsVackJviu7uMkUgUc0o3xAcGLdhBib7bggApRq6QvDyPtil1TCew8WfIMBCNOdbe3r9HjzLb5/fSIiNDfa1I8Gh7jT9M0sUnlfEdDt93P6d/B6s@Zb1aM0L1q8wSp04lwLXrV4@Q2cs7pQwJ/K3Bm8lZwyBy/99DmvS4Ib/bB1AGNr8fgb4zwl/E0bsb8XncQg71mp14@xucgLE9fTmBpz3jWmuO9K/uyEfa/TrCOM3N8xyQTnXogCgsue5cP4wDJL14hkIzjMiqdTQVAce2Lxgku7uIevCHAtjEq/Mg3Z7BViJUbs0nABLUWkFK/xF6LgSltQoDrtlrVFel6o4ld0TJ2N7BwMKu1xlQIwMUOZCI62zs5De9Q7TOJ6Fmmqw1GY3rJZDLkKxevZAP0jn8lq7TCZSvyF0/IjYf76VPSp3cPS50GRZegr@6VxmZt@K@QUzdtUxjPBcVsn1d1OyxJM7ZVWtLaVGLvxgiVbhBTR8mT/a2TdM/oHJvxGPLsE570lWbggyHZvhSYUwPRvw8vx5Mz/ALEmZpUHzUrUviii2UfKf2efdPdO2HazARmuyZDyWv99pKradxfmJBZI@GqvqBiV4J2yiWpY0W01GmxWJQ2ELjqbJRA9J1sl598POm2cVyBiVHEzE2ozOxJrH1pt0PoNbqCWGuMNiqN7PuJvtw4CMvFL6O7odUDO@BLMcwq4hAFOfqWZnb/O8ZQrehjtoLkoH@zk656pTHpkWrGY@hXlUngXAkubMMS23ixu6lncEewB6P6t2dPkzai/ko3O0R2hnsMc3hoVk2pZKJWCXe62aZqVjNRglMHVuIOSbvTPP7JjsxmjwLsK8Z@cA1p@6oJiBp@jB76bi16bD45AGfQ9EvBKU/fA2LQCq4HtvUevQa1S3tfXXcY7pJwUwuLntfaD5ChmQStixWDwsAJzEZaPH3LM7bkzf3OGS8gHwfU8sJ48wxI9ugohIGvthT@eHF2fntxsCr@ncMuJvyUHdyB@x@D0b31ITxF7F@xiQ5@5LN5X8rmvsgF/mOzD@BKjfSRLuhrMiZ7xl63Dviy/OX9@GyC@m5@GHz68sGEM@tOelF36Mq7BW74STY@wmDSYwKd643p9k8AugB6hTV5V7xvQ2ySjcbFzJDGoTuFK9A16BEWZbFjmcwJMjK62Bafw99u6MhfYfZwCCQc/lfQ5pvz/97ZsX8kc2scbwmgbNhilJu@Px6xCDDtjHe6Zu@d4AqN7/@wrSv/Zya6UgDFArV5Z2CfM2K8waG4W35rdq0gBwsp6U9DO7kCIFk2pDmssHM8GCYv9W0XAbA4JFlYdJF1T4fwzWkgwYpI6v/0xlzSfTorimwXKR5Yig933WNuI7JsN6f50Ul@NKT05Mvxx6PPX3L6kcw/DYefP3@e//yJ0pz8TMj8dLe7n6krb9lwWBx/@nQ0O53ns4/HRwUpjr98ph9P8yEhH2df8tnPXz7RE0I/70YS6VBotLV7ghELZAlCMnChO2Qm6@If4CSDGmKi76FGeBPOF3xA2ggrqsb1e8MTFQM5fsr2Wre0b3wx2sJvRFEhF6Dt4RSXyvs/ubHdsZ0lSJvoEuJyZ6oNFG0zz7YY8MV7CakG3MFrRXeRc9It9sBAurOD4HImimZ4dHzSnR6rhrlfqB2aZs/D@Gpn539d4vdtwP8P "sed – Try It Online")
[Answer]
# [Befunge-98](https://github.com/catseye/FBBI), 10 bytes
```
~:'(-!#@_,
```
[Try it online!](https://tio.run/##rVjBbtw2EL3nK1gkhe0m2sQBWqQ@1XUcx4AdG16n7SFAwJUoLWuJVEkq6@2hX9ZbP8x9Q0paSrvrpI1zCBItOZp58@bNjGYib1Qhkh9f3d39dbCzm3zz@KePz@7uzrlxUrGf//nbOSUM291/@WLv4BHzf06VdJKXLNVVJV378DDL2IxbmbLa6N9F2j1/X2fcCXZ1fPj6/HhSZdFxIwpxy3TtpFaWcZWxwoiaVToTtj12Lkwh2Mxwlc7ZTsWtE2aH6ZwV0s2b2QQuHFSzRngvnxsBp3n0BluX0nmDg9fWJU/F@PEFYjmuardkeckL5vTm26XWdTiRa7PNlsPPdglnKyZueVWX8Y@zRpYZ2TdaO5ZJA7C0WbYnjowgvM5Oj47fTUeAZTptKqEcJ8TIwhjVc/1JdG@0/StyXWbCfD2iV6IK9h1uC93Y7lVgQi37nG3J@PEtoAKnXiYrdJ4x3gOC/9ce087/ycNwAM4iQYFlHrP1lL2Rt3CiYAsYREpTXShppSo2nSWTVw1i3t9/0bk6iX4DQqbkdfTCc@7g@MhEInz5gPRJKZXwjBoBOMh25Klb1jqyVBupHDl7zxsDhHVTlgjvj0ZYxx7D/dzoil0aXRhevbn47bmpElfVw2wjS0iLJD7545PUUoE/BJtyTsSH68/YJfSGnW7/5TQKuGpKJy1IJLryI5Tiqoe3ykV4cMQdq8oWhl6fnjE@041jr@EB3vILLxtx6JyRs8aJB5IkRFWKhBBtPexVFYYqkUlyzYcHTbRdMLMly4JTkzEUScCChMlO2K@nl59X3nTOofqlLh4mJlkobQTMAuNWbXwl18JYrdApGtuh917JfMkkxZr7usyhgHkuDAUZou4Ml6VesEreem7nwx9bcp6RGFPjuI6KHCA8ZdIyhet2ro3zvuzuTfq7C21umBWoPidTS8anMWW8cvozM0SMWLwueHw3QesdOHp7@O7k@OziZHRipBRD962uRAAta9Br0qDrgYKtRyPZQJzKoisJ07PEp5ztZlpYteMI6raxLoXb6/LLb8Toro@vFTyc/uLAjjx1RsbAJySAoEpLbu3nCs3LMomQbWDBp@eKnJi0ehszHMTyZ22kgK3G1sSMirSuf@EUEYHCyJ/SKpmVOr2hQ1LVzfqgkkP2AhfIAyUWvd5LytVYez2Iw5nFX74ethK0DsJ0YSg0UGtTZJ2Mw7EWnMi5J4oJm/Ja@Aa@Ujj0TDh0u7Fk22M7Q9zHufMRJNb7y9xcdJLiE02dOKm8XKZzKT6FE7qutZW9@G0x7PuQLFOjF0G0mpl10kE0rceWWlwuRGbvN/NWuxzI0I1zrfT9h98hXzOe3lgwbh6JvW3q2ghrqfHLkrLfvX0lQS7Q7zoZKg6iIBassZnMXidRlq/a9IaHPXzGl4YBdsbyMrK6o3dWNthiLpEzqawwzgaU8ZeBIrn7Qx5WJ8E08MorO69dY0hVGjDGw9GmguAZMKidhSHmK@i2nfXMefL4qWd8/OyDr5Ul63aDKUka4HemSeEIwU9@UpAD6zU3tp9JPesnatP7/e0uKChi4eZx46lINpHOmZjzT1I3oe88@W4Ljj5Tg4LbolAnAo2Ol9K2fZXQKYxu6rCn9OVd98Eg0q9vpqQLvilgGrXUJY3OmhSdFTpBEIKObn3tQpsNQ2TrzrfxuiJxNhRhmAo94@N1wZ9AlAUUEVFexOvYCgWLHi9ztCjlymXkbVDOAjrZmeqrqSZeUD2FN8B2X1gUWzSlkmQsRFmO/aY7J7QSkjOHaNYn3X64HiGVV9STCIdNB7dsAF1BT/3KFwaqrqoHUV0Jjif4i5j9pzC6ndIEOEBEGhxue2V48VrtffQ@BwA8y3vZMTQeDARkJW@abLVU9AP5tN9SGZoEtsk@P1u4PS6KL/mlk8apNn7XGLDo//N9i875fczoG6GCTqfcxonMzJKZRnWgjIp9PNu2s3zbuQloSzPhmvJDtZXPuaZXSDg/kP/1C9WqnqL8IL7GwDcF8jdKYtkajSgdlOEipgBxAB@7AVBE3Y1qOuELbsQ9ynzVa20c@qP2A86xyvzXmx/6jzeEbcXNTaYXiqpw8yowXBW/fxWoBoQy4TAclM9riinZH0IPh29sO7XouEv4eR9dmcjtwgMMZAHtxvl/ooxM4fddEgdwCHUGDlG/IcKFzyTA1I@sCFnwaq3MQpsnBz4oyjc3WUmTAOyg4h1yX7VXLmlp9rZo1l6bFGy0b42KKWjHlJJ3TeDQqIlcEU/bZod0D@9Q0fynCyMh@7K73VC9JvaryRm7iMLIy3KEu/FWJH92fCCcWJfjzaf94YjW68d8n1ud9ZLW7b27YTNqDK2FSHqmabWpUY17YwthlF/ZCWvao9VXDbC/J3/Yu7KtHzUekQZE52kabact/9XlXw "Befunge-98 – Try It Online")
[Answer]
# [Retina](https://github.com/m-ender/retina), 8 bytes
```
s` \(.*
```
[Try it online!](https://tio.run/##rVjBbtw2EL37Kwgkhe0ku4kDtChycx3HMWDHhu20PQRouRKlZS2RLEllvf223vph7htS0lLaXSdtnEOQaMnRzJs3b2ZkhZeK39@739mnvemznfv7c27xiP30z9/eK2HZ3sHrV/tvdlj4c6qkl7xima5r6duHh3nOZtzJjBmr/xBZ9/yjybkX7Or48O358bTOk@NWlOKOaeOlVo5xlbPSCsNqnQvXHjsXthRsZrnK5my35s4Lu8t0wUrp581sChfe1LNGBC9f2hBH8gZnKumDwcFrTcUzMX58gViOa@OXrKh4ybzefLvS2sQThbbbbHn87JZwtmbijtemSn@cNbLKyb7V2rNcWoCl7bI9cWQF4XV2enT84XoEWK6zphbKc0KMLIxRPdefRfdG17@i0FUu7LcjeiXqaN/jttCN614FJhjZ52xLxo/vABU49XqyQucF4z0g@L8JmHb@Tx@HA3AWCYosC5itp@ydvIMTJVvAIFKa6VJJJ1W56SyZvGoQ88HBq87VafIbELIVN8kLz7mH4yMTExHKB6SfVFKJwKgRgINsJ576pdGJJWOl8uTsA2@MEJqmqhDen41wnj2B@4XVNbu0urS8fnfx60tbT3xthtlGlpAWSXwKx6eZowJ/DDYVnIgP11@wS@gNO93@y2kScN1UXjqQSHTlRyilVQ9vlU/w4Ig7VZUtDL05PWN8phvP3sIDvOVnXjXi0HsrZ40XjyRJiKoSE0K09bBXVRiqRS7JtRAeNNF1wcyWLI9OTcdQTCIWJExuyn45vfyy8mZzrkpR6fJxYpKl0lbALDBu1SZUshHWaYVO0bgOvY9KFksmKdYi1GUBBSwKYSnIGHVnuKr0gtXyLnC7GP7YkvOMxJgax01S5ADhOZOOKVx3c2198GVvf9rfXWh7y5xA9XmZOTJ@nVImKGc4M0PEiCXoQsB3E7TBgaP3hx9Ojs8uTkYnRkoxdN/pWkTQ8ga9Jou6HinYejSSDcSpHLqSsD1LQsrZXq6FU7ueoG4b61L4/S6//FaM7ob4WsHD6a8O7ChQZ2QMfEICCKqs4s59qdCCLJMIuQYWQnquyIlpq7cpw0GscNYlCthqrCFm1KR1/QuvEREojPwprSazSme3dEgq06wPKgVkL3KBPFBi0eu9pFyNtTeAOJxZwuWbYStB6yBMF5ZCA7U2RdbJOBxrwUmce6qYcBk3IjTwlcKhZ8Khu40l2x7bHeI@zl2IYOKCv8zPRScpIdHUiSd1kMtsLsXneEIbo53sxW@L4dCHZJVZvYii1cyclx6i6QK21OIKIXL3sJn32hdAhm6ca6UfPvwB@Zrx7NaBcfNE7F1jjBXOUeOXFWW/e/tKgnyk381kqDiIgliwxmYyezNJsnzVpjc@7OGzoTQssLOOV4nVXb27ssEWc4mcSeWE9S6ijL8sFMk/HPKwOgmmgVdB2bnxjSVVacCYAEebCoJnwKB2FoaYr6DbdjYw5@mT54Hx6bNPoVaWrNsNrknSAL@3TQZHCH7yk4IcWDfcun4mDayfqk3vD7e7oKCIpZ@njacm2UQ6Z2LOP0vdxL7z9NkWHEOmBgW3RaFOBBodr6Rr@yqhU1rdmLin9OVt@mAQ6bc3U9KF0BQwjTrqklbnTYbOCp0gCEFHv752oc3GIbJ157t0XZE4G4swToWB8em6EE4gyhKKiCgv0nVshYJDj5cFWpTy1TLxNipnCZ3sTPXVZIgXVE/xDbDdFxbFlkypJBkLUVVjv@nOCa2E5MwhmvVJtx@uR0jllfQkwmHTwS0bQFfQ12HliwNVV9WDqK4ExxP8Rcz@S1jdTmkCHCAiDQ63vTK@eK32fgs@RwACy3vZsTQeDARkJW@abLVUDAP5db@lMjQJbJN9frZwe1wUX/NLJ43X2oZdY8Ci/8/3LToX9jGrb4WKOp1xlyYyt0tmG9WBMir28WzbzvJt5yagHc2Ea8oP1VYh55peIeH8QP7XL9Srekryg/gaC98UyN8oiWVrNKJ0UMaLmALEG/jYDYAi6W5U0xO@4FY8oMxXvdamoe@0H3COVR6@3vzQf7whbGtub3O9UFSFm1eB4ar4/Y@RakAoFx7DQfXSUEyTgyH0cPjWtVOLTrtEmPfRlYncPj7AQBbRbnz4J8rIlmHfJXEAh1Bn4BD1GyJc/EwCTMPIipAFr9fKLLZ5cuCTonxzm1c0CcAOKt4j93V75ZKW5mCLZu21ScEl@9aomKJ2XFPybggcGjWRK@Jp2@yQ7uEdKpr/dGEkZF93txuq18R@NTljF1EYeVmBcDfeSuTPjQ/EE@tyvPl0OJzQev1Y6HOrs0HSur13L25GjaW1EEnPNa02BtW4P7YQR/mVnbim7ay@aoD9Pfnj3pVv/aixQxqQnKdptJ22wleXfwE "Retina – Try It Online") Example input is the output from `shortlog -n` from Retina.
[Answer]
# [Python 3](https://docs.python.org/3/), 29 bytes
```
print(input().split(' (')[0])
```
[Try it online!](https://tio.run/##rVhtb9RGEP7Or1ipVEkKd7xUrSq@pRBCJAIoCW2lUlV79tq3jb3r7q65XH9bv/WH0Wdmbd/adxdogQ8IfLvjmWeeeWbGzTosrfn2w4fGaRMOtWnacHg0902lw@GBODw4@vXhb0cfPpxLF7QRP/7zdwhGOXH46PHDoyd3BP85MzpoWYnM1rUO3cPjPBcL6XUmGmf/UFn//G2Ty6DExcnxs/OTeZ0nx50q1Y2wTdDWeCFNLkqnGlHbXPnu2LlypRILJ022FAe19EG5A2ELUeqwbBdzuPCkXrSKvXzgFJyWyRs4LjY4em1TyUxNH79GLCd1E9aiqGQpgt19u7K2iScK6/bZCvjZr@FsLdSNrJsq/XHR6ion@87aIHLtAJZ16@7EU6cIr5dnT09eXU4Ay23W1soESYiRhSmq5/a96t/oh1cUtsqV@3xEL1Qd7QfcVrb1/avAhEYPOduT8ZMbQAVOPZ5t0Lkv5AAI/t8wpr3/8y/DATiLBEWWMWbbKXuub@BEKVYwiJRmtjTaa1PuOksmL1rE/OjRw97VefIbEHKVbJIXnssAxycmZorLB6SfVdooZtQEwFG2E0/DurGJJa5kcvaWN0YIm7aqEN6frfJBfAX3C2dr8cbZ0sn6@etfHrh6FupmnG1kCWnRxCc@Ps88FfiXYFMhifhw/b54A70RZ/t/OUsCrtsqaA8Sqb78CKW06uGtCQkeEnGnqrKHoVdnL4Vc2DaIZ/AAb/lJVq06DsHpRRvUF5IkRFWpGSHaeTioKgzVKtfkGocHTfR9MIu1yKNT8ykUs4gFCZOfi5/P3nxcebOlNKWqbPllYtKlsU7BLDDu1IYruVHOW4NO0foevbdGF2uhKdaC67KAAhaFchRkjLo3XFV2JWp9w9wuxj925HxJYkyN4yopcoBwT2gvDK77pXWBfUGXG@6urLsWXqH6gs48Gb9MKcPKyWcWiBixsC4wvrugZQeevjh@dXry8vXp5MREKcbue1urCFreotdkUdcjBTuPJrKBOI1HV1JuYAmnXBzmVnlzEAjqrrGuVTjq8yuv1eQux9cJHk5/cmBPmToTY@ATEkBQZZX0/mOFxrJMIuRbWOD0XJAT805vU4aDWHzWJwrYaWxDzKhJ64YXXiIiUBj5M9bMFpXNrukQzzlbg0oB2YtcIA@MWg16rylXU@1lEMczC1@@GrcStA7CdOUoNFBrV2S9jMOxDpzEubtGKJ/JRnED3ygceiYcutlZst2xgzHu09xxBDPP/oqwVL2kcKKpE89qlstsqdX7eMI2jfV6EL89hrkP6SpzdhVFq134oANE0zO21OIKpXJ/u5kXNhRAhm6cW2NvP/wK@VrI7NqDcctE7H3bNE55T41fV5T9/u0bCQqRflezseIgCmLBFpvJ7NUsyfJFl974cIDPcWk4YOe8rBKrB/ZgY0Oslho508YrF3xEGX85KFK4PeRxdRJMI69Y2WUTWkeq0oIxDEeXCoJnxKBuFoaYb6Dbd5aZc/ere8z49Nk7rpW16HeDS5I0wB9cm8ERgp/8pCBH1hvp/DCTMuvnZtf7@XYfFBSxDMu08dQkm0jnQi3le23b2HfufrMHR87UqOD2KNSpQqOTlfZdXyV0SmfbJu4pQ3k3QzCI9PObKekCNwVMo566pLN5m6GzQicIQtAxbK9daLNxiOzc@TpdVzTOxiKMUyEzPl0X@ASiLKGIiPJ1uo5tUPDo8bpAizKhWifeRuUsoZO9qaGaGuIF1VN8A2wPhUWxJVMqScZKVdXUb7pzSishOXOMZn3a74fbEVJ5JT2JcNh1cM8G0Bf0Ja98caDqq3oU1YWSeIK/iNl/KWe7KU2BA0Sk0eGuV8YXb9Xe7@xzBIBZPsiOo/FgJCAbebNkq6MiD@SXw5Yq0CSwTQ752cPtaVF8yi@9NF5ax7vGiEX/n@97dI73MWevlYk6nUmfJjJ3a@Fa04MyKfbpbNvN8l3nJqA9zYRbyg/VNpxzS6/QcH4k/9sX6k09JflBfK2Dbwbkb43GsjUZUXoo40VMAeoJfOwHQJV0N6rpmVxJp25R5otBa9PQ73QfcE5Mzl9vvh8@3hC2tXTXuV0ZqsLdq8B4Vfzuh0g1IJSrgOGgetBQTLNHY@jh8LXvphabdgme99GVidwhPsBAFtFuA/8TZeRK3ndJHMAh1Bk4RP2GCBc/kwBTHlkRspL1VpnFNk8OvDOUb@nyiiYB2EHFB@S@7q68oaWZbdGsvTUp@GTfmhRT1I5LSt4VgUOjJnJFPO2aHdI9vkNF858uTITs0@72Q/WW2G8mZ@wiBiOvKBDuzluJ/PnpgXhiW453n@bDCa23j3Gf25xlSev33sO4GbWO1kIkPbe02jSoxqOphTjKb@zENe3O5qsG2D@QP@5d@d6PGndIA5LzNI120xZ/dfkX "Python 3 – Try It Online") Example input is the output from `shortlog -n` from Retina.
[Answer]
# [AWK](https://www.gnu.org/software/gawk/manual/gawk.html), 9 bytes
```
NR<2,NF--
```
[Try it online!](https://tio.run/##rVjfb9s2EH7PX0FgHZKstdsU2DAUe8lSNw2QX7DTbQ8FBlqiZM4SqZFUHe9v29v@sOw7UpIp2U67NX0oWpk83X333Xd34qvlw8P19KfXL67fjUYPD1fcOKnYz//87ZwShh2dvH51/OaA@T8XSjrJC5bospSueXiapmzOrUxYZfQfImmff6hS7gSbTk7fXk3GZRodNyIX90xXTmplGVcpy42oWKlTYZtjV8Lkgs0NV8mCHZbcOmEOmc5YLt2ino/hwptyXgvv5Usj4DSP3mCrQjpvsPfaquCJGD6@QSyTsnJrlhU8Z07vvl1oXYUTmTb7bDn8bNdwtmTinpdVEf84r2WRkn2jtWOpNABLm3Vz4swIwuvy4mxyPRsAluqkLoVynBAjC0NUr/Qn0b7Rdq/IdJEK8/WITkUZ7DvcFrq27avAhEp2OduT8ck9oAKnXo826LxgvAME/688pq3/46fhAJxFggLLPGbbKXsn7@FEzlYwiJQmOlfSSpXvOksmpzViPjl51bo6jn4DQqbgVfTCK@7g@MDESPjyAelHhVTCM2oAYC/bkaduXenIUmWkcuTsI28MEFZ1USC8P2thHfsG7mdGl@zW6Nzw8t3Nby9NOXJl1c82soS0SOKTPz5OLBX4U7Ap40R8uP6C3UJv2MX@Xy6igMu6cNKCRKItP0Iprnp4q1yEB0fcsarsYejdxSXjc1079hYe4C2/8KIWp84ZOa@deCJJQlSFGBGijYedqsJQKVJJrvnwoIm2DWa@ZmlwajyEYhSwIGGyY/brxe3nlTdZcJWLQudPE5PMlTYCZoFxoza@kithrFboFLVt0fugZLZmkmLNfF1mUMAsE4aCDFG3hotCr1gp7z23s/6PDTkvSYypcdxFRQ4QnjNpmcJ1u9DGeV@Ojsfd3ZU2S2YFqs/JxJLxWUwZr5z@zBwRIxavCx7fXdB6B87en16fTy5vzgcnBkrRd9/qUgTQ0hq9Jgm6HijYeDSQDcSpLLqSMB1LfMrZUaqFVYeOoG4a61q44za/fCkGd318jeDh9BcHduapMzAGPiEBBFVScGs/V2helkmEbA0LPj1TcmLc6G3McBDLn7WRAjYaWxEzStK67oUzRAQKI39Kq9G80MmSDklV1duDSgbZC1wgD5RYdXovKVdD7fUg9mcWf/mu30rQOgjTlaHQQK1dkbUyDscacCLnnikmbMIr4Rv4RuHQM@HQ/c6SbY4d9nEf5s5HMLLeX@YWopUUn2jqxKPSy2WykOJTOKGrSlvZid8ew74PySIxehVEq55bJx1E03psqcVlQqT2cTPvtcuADN240ko/fvga@ZrzZGnBuEUk9rauKiOspcYvC8p@@/aNBLlAv7tRX3EQBbFgi81k9m4UZXnapDc87OAzvjQMsDOWF5HVQ324scFWC4mcSWWFcTagjL8MFMk9HnK/Ogmmnlde2XnlakOqUoMxHo4mFQRPj0HNLAwx30C376xnzrNvnnvGx88@@lpZs3Y3mJGkAX5n6gSOEPzkJwXZs15xY7uZ1LN@rHa9399ug4Ii5m4RN56SZBPpnIsF/yR1HfrOs@/24Ogz1Su4PQp1LtDoeCFt01cJndzougp7SlfeVRcMIv36Zkq64JsCplFLXdLotE7QWaETBCHo6LbXLrTZMEQ27nwbrysSZ0MRhqnQMz5eF/wJRJlDERHlTbyObVCw6PEyQ4tSrlhH3gblzKGTramumiriBdVTeANsd4VFsUVTKknGShTF0G@6c04rITlzimZ93u6H2xFSeUU9iXDYdXDPBtAW9MyvfGGgaqu6F9VUcDzBX8Tsv4TRzZQmwAEiUu9w0yvDi7dq73fvcwDAs7yTHUPjQU9ANvKmyVZDRT@Qz7otlaFJYJvs8rOH28Oi@JJfWmmcaeN3jR6L/j/f9@ic38eMXgoVdDrhNk5katbM1KoFZVDsw9m2meWbzk1AW5oJt5Qfqq18zjW9QsL5nvxvXyg39RTlB/HVBr4pkL9WEsvWYERpoQwXMQWIN/CxHQBF1N2opkd8xY14RJmnndbGoR80H3AmKvVfb37oPt4QtiU3y1SvFFXh7lWgvyp@/2OgGhBKhcNwULysKKbRSR96OLy0zdSi4y7h5310ZSK3Cw8wkAW0a@f/iTIyud93SRzAIdQZOET9hggXPpMAUz@yImTBy60yC22eHPioKN/cpAVNArCDinfIfdlcuaWl2duiWXtrUrDRvjUopqAdM0reHYFDoyZyRTxtmh3S3b9DRfOfLgyE7MvutkP1lthvJmfsIgojL8sQ7s5bkfzZ4YFwYluOd5/2hyNabx/zfW5z1ktau/cehc2oNrQWIumpptWmQjUeDy2EUX5jJ6xpB5uvGmB/R/6wd6V7P2ockAZE52kabaYt/9XlXw "AWK – Try It Online")
This one is just a test, consisting of two statements, without any associated code block. The first test `NR<2` determines the truthy'ness of the test. So the default code block, which is effectively `print $0`, is only run for the first line of the input.
The secondary statement, `NF--` just drop the last field in the input line.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 4 bytes
```
'(¡¬
```
[Try it online!](https://tio.run/##7VjNbtw2EL77KQgkhe0mu4kDpChycxPHMRDHhu20PQQouBKlZS2RKkllvX2b3vsIPaUP5n5DSlpKu@ukjW9VDkGiJYcz38x88/P0OZ8diNvb3b1Pf3z68/b2lBsnFfvh77@cU8KwvYNnT/df7DD/50RJJ3nBEl2W0jUfD9OUzbiVCauM/lUk7ff3VcqdYBdHh69Oj6ZlGh03Ihc3TFdOamUZVynLjahYqVNhm2OnwuSCzQxXyZztltw6YXaZzlgu3byeTaHCi3JWC6/lEyOgNI9esFUhnRfYe7YqeCKGn89gy1FZuSXLCp4zpzffLrSuwolMm22yHH62SyhbMnHDy6qIf5zVskhJvtHasVQagKXNsjnx0gjC6@3Jy6N3lwPAUp3UpVCOE2IkYYjqqf4o2hdt90Smi1SYr0f0QpRBvsNtoWvbPoVIqGTnsy0eP7oBVIipZ5MVOo8Z7wDB/yuPaav/9H5iAMrCQSHKPGbrLnstb6BEzhYQCJcmOlfSSpVvOksiL2rYfHDwtFV1Gv0GhEzBq@jBU@6g@EDERPj0QdBPCqmEj6gBgD1vR5q6ZaUjSZWRypGyd7wYIKzqooB5v9XCOvYA6mdGl@zc6Nzw8vXZz09MOXFl1fc2vAS3SIonf3yaWErw@4imjFPgQ/XH7Bx8w062/3ISGVzWhZMWQSTa9COU4qyHtspFeHDYHbPKlgi9OnnL@EzXjr2CBnjlR17U4tA5I2e1E/dESbCqEBNCtNGwY1UIKkUqSTVvHjjRtsbMliwNSk2HUEwCFkRMdsp@Ojn/PPMmc65yUej8fmySudJGQCwwbtjGZ3IljNUKlaK2LXrvlcyWTJKtmc/LDAyYZcKQkcHqVnBR6AUr5Y2P7az/YxOcb4mMqXBcRUkOEB4xaZnCdTvXxnld9van3d2FNtfMCmSfk4kl4ZdxyHjm9GdmsBi2eF7w@G6C1ivw8s3hu@Ojt2fHgxMDpuirb3UpAmhpjVqTBF4PIdhoNKAN2KksqpIwXZR4l7O9VAurdh1B3RTWpXD7rX/5tRjc9fY1hIfTX2zYSx86A2GIJziAoEoKbu3nEs3TMpGQrSHBu@eClJg2fBtHOALLn7URAzYcW1FklMR13YOXsAghDP8prSazQifXdEiqql5vVDLQXogF0kCJRcf3knw15F4PYr9n8Zev@qUEpYMwXRgyDaG1ybKWxqFYA06k3EPFhE14JXwBXzEcaiYUutmYss2x3T7uQ995CybW68vcXLSU4h1NlXhSerpM5lJ8DCd0VWkrO/LbItjXIVkkRi8CadUz66QDaVqPLZW4TIjU3i3mjXYZkKEbp1rpuw@/g79mPLm2iLh5RPa2riojrKXCLwvyfvv6ioJcCL@rSZ9xYAVFwVo0k9irSeTli8a94WMHn/GpYYCdsbyIpO7q3ZUMtphL@EwqK4yzAWX8ZcBI7m6T@9lJMPW08szOK1cbYpUaEePhaFxB8PQiqOmFQeYr6Lad9ZHz8MEjH/Hxtw8@V5asnQ0uidIAvzN1AkUIftKTjOxJr7ixXU/qo36qNr3vb7dGgRFzN48LT0m0CXfOxJx/lLoOdefht1tw9J7qJdwWhjoWKHS8kLapq4RObnRdhTmlS@@qMwaWfn0xJV7wRQHdqKUqaXRaJ6is4AmCEOHo1sculNnQRDbqfBOPKxJnQxKGrtBHfDwu@BOwMgcjwsqzeBxboWBR42WGEqVcsYy0DcyZgydbUV02VRQXlE/hBcjuEotsi7pUooyFKIqh3nTnmEZCUuYQxfq4nQ/XLaT0imoS4bDp4JYJoE3oSz/yhYaqzeqeVReC4wv@osj@XRjddGkCMUCB1Dvc1Mrw8Fru/eJ1DgD4KO9ox1B70COQFb1pktWEom/IL7splaFIYJrs/LMltodJ8SW/tNR4qY2fNXpR9N/jfQvP@XnM6GuhAk8n3MaOTM2SmVq1oAySfdjbNr18U7kJaEs94Rrzg7WV97mmJySU79H/@oVylU@Rf2BfbaCbQvDXSmLYGrQoLZThIroA8QI6tg2giKob5fSEL7gRdzDzRce1sek7zQLnSKV@e/Ndt7whbEturlO9UJSFm0eB/qj4/PsQakAoFQ7NQfGkIpsmB33oofC1bboWHVcJ3@@jKlNwu/ABDVlAu3b@n0gjk/t5l8gBMYQ8QwxRvaGAC2sSYOpbVpgseLmWZqHMkwIfFPmbm7SgTgBykPEOvi@bK@c0NHtZ1GuvdQo2mrcGyRS445Kcd0XgUKsJX1GcNsUO7u7foaT5VxcGRPZld9umeo3sV50zZhGFlpdlMHfjrYj@7PBAOLFOx5tP@8NRWK8f83VuddZTWjv37oXJqDY0FsLpqabRpkI27g8lhFZ@JSeMaTurrQaivwv@MHelW5caO8QB0XnqRptuy29dxrXouBYd16LjWnRci45r0XEtOq5Fx7XouBYd16LjWnRci45r0XEtOq5Fx7XouBYd16LjWvR/thb9Bw "05AB1E – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 4 bytes
```
ṣ”(Ḣ
```
[Try it online!](https://tio.run/##7VjNbtw2EL77KQg0hZ0mu4kDtChycxPHMWDHge20PQQouBKlZSyRKkllvT31RXppX6IFeuuTpC/ifkNKWkq766RNblUOQaIlhzPfzHzz80YUxfLm5t0fv/398y97737/9ebm5pQbJxX75q8/nVPCsL39Rw/vPt5h/s@xkk7ygiW6LKVrPh6kKZtxKxNWGf1GJO33V1XKnWDnhwdPTw@nZRodNyIX10xXTmplGVcpy42oWKlTYZtjp8Lkgs0MV8mc7ZbcOmF2mc5YLt28nk2hwuNyVguv5QMjoDSPXrBVIZ0X2Hu2Kngihp/PYMthWbklywqeM6c33y60rsKJTJttshx@tksoWzJxzcuqiH@c1bJISb7R2rFUGoClzbI58cQIwuvk@Mnhi4sBYKlO6lIoxwkxkjBE9VS/Fe2Ltnsi00UqzMcjei7KIN/httC1bZ9CJFSy89kWjx9eAyrE1KPJCp37jHeA4P@Vx7TVf/ppYgDKwkEhyjxm6y57Jq@hRM4WEAiXJjpX0kqVbzpLIs9r2Ly//7BVdRr9BoRMwavowVPuoPhAxET49EHQTwqphI@oAYA9b0eaumWlI0mVkcqRsre8GCCs6qKAeT/Wwjr2GdTPjC7ZS6Nzw8tnZ98/MOXElVXf2/AS3CIpnvzxaWIpwT9FNGWcAh@q32cvwTfsePsvx5HBZV04aRFEok0/QinOemirXIQHh90xq2yJ0MvjE8ZnunbsKTTAK9/yohYHzhk5q534RJQEqwoxIUQbDTtWhaBSpJJU8@aBE21rzGzJ0qDUdAjFJGBBxGSn7Lvjl@9n3mTOVS4KnX8am2SutBEQC4wbtvGZXAljtUKlqG2L3islsyWTZGvm8zIDA2aZMGRksLoVXBR6wUp57WM76//YBOcJkTEVjssoyQHCPSYtU7hu59o4r8ve3Wl3d6HNFbMC2edkYkn4RRwynjn9mRkshi2eFzy@m6D1Cjx5fvDi6PDk7GhwYsAUffWtLkUALa1Ra5LA6yEEG40GtAE7lUVVEqaLEu9ytpdqYdWuI6ibwroU7m7rX34lBne9fQ3h4fQHG/bEh85AGOIJDiCokoJb@75E87RMJGRrSPDuOSclpg3fxhGOwPJnbcSADcdWFBklcV334AUsQgjDf0qryazQyRUdkqqq1xuVDLQXYoE0UGLR8b0kXw2514PY71n85ct@KUHpIEwXhkxDaG2yrKVxKNaAEyl3RzFhE14JX8BXDIeaCYWuN6Zsc2y3j/vQd96CifX6MjcXLaV4R1MlnpSeLpO5FG/DCV1V2sqO/LYI9nVIFonRi0Ba9cw66UCa1mNLJS4TIrW3i3muXQZk6MapVvr2wy/grxlPriwibh6Rva2ryghrqfDLgrzfvr6iIBfC73LSZxxYQVGwFs0k9nISefm8cW/42MFnfGoYYGcsLyKpu3p3JYMt5hI@k8oK42xAGX8ZMJK73eR@dhJMPa08s/PK1YZYpUbEeDgaVxA8vQhqemGQ@Qq6bWd95Nz57J6P@Pjba58rS9bOBhdEaYDfmTqBIgQ/6UlG9qRX3NiuJ/VRP1Wb3ve3W6PAiLmbx4WnJNqEO2dizt9KXYe6c@eLLTh6T/USbgtDHQkUOl5I29RVQic3uq7CnNKld9UZA0s/vpgSL/iigG7UUpU0Oq0TVFbwBEGIcHTrYxfKbGgiG3U@j8cVibMhCUNX6CM@Hhf8CViZgxFh5Vk8jq1QsKjxMkOJUq5YRtoG5szBk62oLpsqigvKp/ACZHeJRbZFXSpRxgJT6FBvunNEIyEpc4BifdTOh@sWUnpFNYlw2HRwywTQJvSFH/lCQ9Vmdc@qc8HxBX9RZP8kjG66NIEYoEDqHW5qZXh4Lfd@8DoHAHyUd7RjqD3oEciK3jTJakLRN@QX3ZTKUCQwTXb@2RLbw6T4kF9aarzQxs8avSj67/G@hef8PGb0lVCBpxNuY0emZslMrVpQBsk@7G2bXr6p3AS0pZ5wjfnB2sr7XNMTEsr36H/9QrnKp8g/sK820E0h@GslMWwNWpQWynARXYB4DB3bBlBE1Y1yesIX3IhbmPm849rY9J1mgXOoUr@9@apb3hC2JTdXqV4oysLNo0B/VPzy6xBqQCgVDs1B8aAimyb7feih8JVtuhYdVwnf76MqU3C78AENWUC7dv6fSCOT@3mXyAExhDxDDFG9oYALaxJg6ltWmCx4uZZmocyTAq8V@ZubtKBOAHKQ8Q6@L5srL2lo9rKo117rFGw0bw2SKXDHBTnvksChVhO@ojhtih3c3b9DSfOvLgyI7MPutk31GtmvOmfMIgotL8tg7sZbEf3Z4YFwYp2ON5/2h6OwXj/m69zqrKe0du7dC5NRbWgshNNTTaNNhWy8O5QQWvmVnDCm7ay2Goj@LvjD3JVuXWrsEAdE56kbbbotv3UZ16LjWnRci45r0XEtOq5Fx7XouBYd16LjWnRci45r0XEtOq5Fx7XouBYd16LjWnRci45r0f/ZWvQf "Jelly – Try It Online")
My first Jelly answer!
**How?**
```
ṣ”(Ḣ - Main Link. Takes a string X on left
ṣ - Split X on the occurrences of
”( - Literal "("
Ḣ - Head
```
] |
[Question]
[
Input: an array of length \$n\$ containing integers in the range \$0\$ to \$2n\$.
For each integer \$x\$ in the array, compute the number of integers that *occur before \$x\$* that are no larger than \$x\$.
As an example, if the array is
```
[3, 0, 1, 4, 3, 6]
```
the output should be equivalent to:
```
3: 0
0: 0
1: 1
4: 3
3: 3
6: 5
```
How quickly can you compute this as a function of \$n\$?
[Answer]
# Python, \$O(n \frac{\log n}{\log \log n})\$
Uses the approach from the paper "[Optimal Algorithms for List Indexing and Subset Rank](https://www.semanticscholar.org/paper/Optimal-Algorithms-for-List-Indexing-and-Subset-Dietz/f0e722bcd64611ff1b2ef4618c884bfa685696b1)".
```
import math
def partial_sums(arr):
for i in range(1, len(arr)):
arr[i] += arr[i - 1]
return [0] + arr
class ShortSum:
cache = None
def __init__(self, size):
self.sz = size
self.logsz = int(math.log2(size)) + 1
if ShortSum.cache is None:
ShortSum.cache = [partial_sums([(v >> (i * self.logsz)) & ((1 << self.logsz) - 1) for i in range(self.sz)])
for v in range(1 << (self.sz * self.logsz))]
self.cnt = 0
self.b = [0] * size
self.c = 0
def prefix(self, v):
return self.b[v] + ShortSum.cache[self.c][v]
def inc(self, v):
self.c += 1 << (v * self.logsz)
self.cnt += 1
if self.cnt == self.sz:
self.cnt = 0
for i in range(self.sz):
self.b[i] += ShortSum.cache[self.c][i]
self.c = 0
class Tree:
def __init__(self, l, r, branching_factor):
self.sum = 0
self.sons = []
self.sons_sum = ShortSum(branching_factor)
self.l = l
self.r = r
self.branching_factor = branching_factor
if r - l > 1:
for i in range(branching_factor):
sl = l + (r - l) * i // branching_factor
sr = l + (r - l) * (i + 1) // branching_factor
self.sons.append(Tree(sl, sr, branching_factor))
def count(self, ind):
if self.l == self.r:
return 0
if self.l + 1 == self.r:
return self.sum
son_ind = ((ind - self.l + 1) * self.branching_factor - 1) // (self.r - self.l)
return self.sons_sum.prefix(son_ind) + self.sons[son_ind].count(ind)
def inc(self, ind):
if self.l == self.r:
return
if self.l + 1 == self.r:
self.sum += 1
return
son_ind = ((ind - self.l + 1) * self.branching_factor - 1) // (self.r - self.l)
self.sons_sum.inc(son_ind)
self.sons[son_ind].inc(ind)
def counts(L):
N = len(L)
logN = int(math.log2(N)) + 1
sqrtlog = math.isqrt(logN) + 1
ShortSum.cache = None
t = Tree(0, 2 * N + 1, sqrtlog)
ans = []
for v in L:
ans.append(t.count(v))
t.inc(v)
return ans
```
[Attempt This Online!](https://ato.pxeger.com/run?1=tVZLbtswEN0WOsWsCiqRHTkpisKIcwLDm3QnCIIi0zEBmVJJyUhylW6yaU_TCzSn6QxJ_Swl_QDVxtb8570ZUl-_l4_VvpDPz9_qajf79PLuhziUhargkFZ7z_O2fAdlqiqR5omuD5qlSvlLD_DZFQoECAkqlfecLQLIuTR6Z0APvkYihvOV_QczWMRGqXhVKwlRiErSYa4sT7WG2z2mv60PNkaWZnsOK9gUkntGQhUliZCiShKmeb4LQIsn3stJwrl-Qi9SDMV5cW80QlaMWiTBJTMBfCxk0VqLXVvJ3BYhtKmiy0PPic0KogFaETvCzQ0wAWe9_JjqPTC2gOvrvpTA8U9hdc34sT_IO37I79ijg4I33ifZ4yEmmayw8HAovKNekJyzCRAzY96yUSq-Ew-Oi2OPCMexjRcdiekhXpENF6OuCydkNhHLJcZBsp0dhz2NOyLLPptdq6tmQoZUTmLRIDvByHJEiGvUzvsrnYp4IqnF0y3AZ8XdkE2Meh6ACuAOK8n2Qt4nuzSrCjUa_vowZlQXUhOp8VicWIemZDaKf7JEaJsPRQpF6mSCToKgxamoz4_C8c_hBhbLt8B_o_M2uSkPZ42ZkD4OioCLi9eTt45q5IiLe05L-UfuDZrztCy53DIikmlkTE9R5ncTnxU1HkeWYCG3vZ6auc3bqVXDht2KhRMeWPhvvJpZ6XgrJI7bFmFgjH5nvVh-s3AjXmcOIeYmofHyJw-CZt7mzbFhc9Lp2-ojJ4znFhrSTx0Q_wTW30HV7tPgPJmI9r-wG4JmeneIjU063MjOoua1E6bZ2qG1oUHHy3ptY-ARuhndiZvehai_qAqFaGP0gt4ZeXUmo4vQ3NikoQPVrEIYwCUCsSGfoIlpK0j7R1N7k6173xHdWlVuKI5-h0BlGj76_U8LdLEfNT9fSkW9ORCiqwCwFCzhQwD4_2NMu-g-e5CfbXHwPKoh6d2moUNuTWVaozn9UFzqKwxDe3UPnFAYN_1dkidSyB7hegUPxvjRdBktRezu_QAVKOKyPnCVVhwZcgG05lheyyONKwW1HTafb78A)
The complexity of `ShortSum`'s operations is amortized \$O(1)\$ + a one-time \$o(n)\$ for initialization of `cache`.
The cost of `Tree.__init__` is the number of nodes, which is \$O(n)\$.
The cost of `Tree.inc` and `Tree.prefix` each is the depth of the tree, which is \$\log\_{\sqrt{\log{n}}}{\log{n}} = O(\frac{\log{n}}{\log \log n})\$.
They are run \$n\$ times, so the total cost is \$O(n \frac{\log{n}}{\log \log n})\$
[Answer]
# Python, \$O(n \log n)\$
Simple algorithm based on merge sort that runs in \$O(n \log n)\$ for inputs in any range (assuming comparisons are \$O(1)\$).
```
def counts_by_value(array: list[int]) -> list[tuple[int, int]]:
"""Returns a list of (index, count) tuples ordered by array[index]."""
if len(array) == 1:
return [(0, 0)]
mid = len(array) // 2
lcounts = counts_by_value(array[:mid])
rcounts = counts_by_value(array[mid:])
lpos = rpos = 0
counts = []
while lpos < mid or rpos < len(rcounts):
if lpos < mid and (
rpos >= len(rcounts)
or array[lcounts[lpos][0]] <= array[mid + rcounts[rpos][0]]
):
counts.append(lcounts[lpos])
lpos += 1
else:
counts.append((mid + rcounts[rpos][0], lpos + rcounts[rpos][1]))
rpos += 1
return counts
def counts(array: list[int]) -> list[int]:
"""Returns a list of counts ordered by index."""
return [count for i, count in sorted(counts_by_value(array))]
```
[Attempt This Online!](https://ato.pxeger.com/run?1=hVNBboMwEDz0xiu2OdkKSUhbVRUKeUSvlhWRYhQkF5AxbXlLL7m0f2pfU3ttILRR6gvYOzs7g4f3z7rTh6o8Hj9anS8evq9UJnJ4qtpSN7t9t3tJZStIqlTaxSCLRrOi1JzCYut2uq2lsGch2AKPAzBrNps9Ct2qsoEUcVDlQIoyE2-hI6eAnQ1UZqASGew7wCkMUXxpKJCqyEGK0imgkCSwdiPsUjgDGIlCiCgPsPBcZJCc9qxWcIMV6WyZ6ll_LDatnCJU_QM1yNhDZV1ZnHKPCM-GbsZx_3oopHDIDQqslGvYoFA_jY7OrOsRnZYZkKGG-mxxm0y6JwAzwCn1ppml4yziHDYJDCZg3ltlqgcMPCd6RlPLtK5FmZEJ73Q2Kp-bmxpOhWzEJTJyXkroqX4V1pzSv19jGOhT4VqCIBgDfSHHdnchu_5CT8KKMR1S2icRcZCbr1_4oBsgNJXSIiNno0Qpd7_e13WtjAqPIuzWZDqEdQh3IZj3e2PaAft_9Qc)
] |
[Question]
[
There is an `N x N` square of numbers.
* All columns increase strictly monotonically from top to down
* All rows increase strictly monotonically from left to right
* There is exactly one valid answer for each input.
You are given `2N-1` rows of `N` numbers representing rows or columns in this square. The task is to find the row that isn't in the input.
**Your Task**
Write a program or function that outputs the row or column that isn't in the input.
**Input**
First, you get the number `N`.
Then follow `2N-1` lines of `N` space-separated numbers, representing rows or columns of this `N x N` square. The lines are given in left-to-right or top-down order. There may be multiple equal lines. It is ok to omit the initial `N` from the input, or modify the input format as you like.
```
3
1 2 3
2 3 5
3 5 6
2 3 4
1 2 3
```
**Output**
Your program or function should output a single line of `N` numbers; the row or column from the square that was not present in the input. You may change the output format as you please.
```
3 4 6
```
This would correspond to one of two squares:
```
1 2 3 1 2 3
2 3 4 2 3 5
3 5 6 3 4 6
```
Either way, the output is the same.
**Bonus**
Your solution should be able to calculate `2 ≤ N ≤ 10` within a minute on a normal computer. If your solution handles the big input, `2 ≤ N ≤ 50`, within a minute, you get `-10%` byte count.
**Test cases**
```
2
22 222
2 22
22 222
-> 2 22
3
1 2 3
2 3 5
3 5 6
2 3 4
1 2 3
-> 3 4 6
4
11 14 16 22
3 6 9 11
6 7 11 14
9 11 15 19
10 11 19 22
6 7 10 11
3 6 8 10
-> 8 10 15 16
```
Note that you can simply change what line in these inputs that is omitted, and reorder them in any way you want, to generate new test cases.
This is a simplified version of Google Code Jam 2016 round 1A problem B: Rank and File. The original Google Code Jam problem, where you can get more test cases (but without answers), is available here: <https://code.google.com/codejam/contest/4304486/dashboard#s=p1>
[Answer]
# CJam, 5 - 10% = 4.5
This is an unnamed function (block) that takes an array of arrays and returns an array:
```
{:^$}
```
(With some inspiration from Dennis)
[Try it online](http://cjam.aditsu.net/#code=e%23%20the%20input%3A%0A%5B%5B1%202%203%5D%0A%5B2%203%205%5D%0A%5B3%205%206%5D%0A%5B2%203%204%5D%0A%5B1%202%203%5D%5D%0A%0A%7B%3A%5E%24%7D%0A%0A~p%20%20e%23%20execute%20and%20pretty%20print)
And here is the code I actually submitted at GCJ (24 bytes):
```
li2*({l~}*]$e`{(2%*~}%S*
```
[Try it online](http://cjam.aditsu.net/#code=li2*(%7Bl~%7D*%5D%24e%60%7B(2%25*~%7D%25S*&input=3%0A1%202%203%0A2%203%205%0A3%205%206%0A2%203%204%0A1%202%203)
**Explanation:**
This basically lists the values that appear an odd number of times.
```
:^ reduce by symmetric difference; pairs of duplicate values "cancel" each other
$ sort the resulting array
```
[Answer]
# [Jelly](http://github.com/DennisMitchell/jelly), 3.6 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
œ^/Ṣ
```
The source code is **4 bytes** long and qualifies for the **-10% bonus**. [Try it online!](http://jelly.tryitonline.net/#code=xZNeL-G5og&input=&args=W1sxLDIsM10sWzIsMyw1XSxbMyw1LDZdLFsyLDMsNF0sWzEsMiwzXV0)
### How it works
Since there are **2N** rows/columns in total, each number must appear **2N** times. Therefore, it suffices to take the numbers that appear in an odd number of the **2N - 1** rows/columns from input.
```
œ^/Ṣ Main link. Argument: A (2D list of integers)
/ Reduce the rows by...
œ^ symmetric multiset difference.
Ṣ Sort the result.
```
[Answer]
# JavaScript (ES6), 179 bytes
```
f=(n,a,p=[],o)=>(p[n-1]?p.every((_,j)=>~(a.map(v=>v+"").indexOf((m=p.map((_,k)=>p.map(r=>r[k]))[j])+""))?1:o=!o&&m):a.map((c,i)=>o=o||f(n,x=a.slice(),p.concat(x.splice(i,1)))))&&o
```
## Explanation
Whew! That took quite a bit of effort to do without any combinatorics built-ins...
Possibly qualifies for the bonus. I haven't tested with `n = 50`.
The entire function is a recursive permutation function. It takes the size `n` and input array `a`, then moves each item individually from `a` to the current permutation array `p`. `p` becomes every permutation of *rows*.
Once the length of `p` becomes `n`, it transposes `p` to get an array of the columns. It searches these columns for each item in `a`.
Because `a` should contain all these columns except one if this is the correct result, output the column in the transposed `p` which is missing from `a` if there is only one column missing.
```
f=(n,a,p=[],o)=>(
p[n-1]? // once p is a square
p.every((_,j)=> // find each column in the transposed square a,
// a is missing a column so one should fail
~(a.map(v=>v+"") // convert column arrays to strings so we can use indexOf
.indexOf( // search for current column
(m=p.map((_,k)=>p.map(r=>r[k]))[j])+"" // transpose p to match a
)
)?1:o=!o&&m // if there is only one column missing from a, o = missing column
)
:a.map((c,i)=> // add each row to the permutation
o=o|| // set o to first found result
f(n,x=a.slice(),p.concat(x.splice(i,1))) // get next permutation
)
)&&o // return o
// Test
var testCases = [[
2, [
[22,222],
[2,22],
[22,222]
]
], [
3, [
[1,2,3],
[2,3,5],
[3,5,6],
[2,3,4],
[1,2,3]
]
], [
4, [
[11,14,16,22],
[3,6,9,11],
[6,7,11,14],
[9,11,15,19],
[10,11,19,22],
[6,7,10,11],
[3,6,8,10]
]
]];
document.write("<pre>"+testCases.map(c=>f(c[0],c[1])).join`\n`);
```
[Answer]
# Pyth, ~~13~~ ~~12~~ ~~11~~ 9 x 0.9 = 8.1 bytes
```
S{f%/QT2Q
```
Flattened list as input.
[Try it online!](http://pyth.herokuapp.com/?code=S%7Bf%25%2FQT2Q&input=%5B1%2C2%2C3%2C2%2C3%2C5%2C3%2C5%2C6%2C2%2C3%2C4%2C1%2C2%2C3%5D&debug=0)
### previous 11-byte solution
```
M-+GH@GHSgF
```
Uses Dennis' algorithm.
### previous 12-byte solution:
```
S{f%/.nQT2.n
```
[Try it online!](http://pyth.herokuapp.com/?code=S%7Bf%25%2F.nQT2.n&input=%5B%5B1%2C2%2C3%5D%2C%5B2%2C3%2C5%5D%2C%5B3%2C5%2C6%5D%2C%5B2%2C3%2C4%5D%2C%5B1%2C2%2C3%5D%5D&debug=0)
## alternative 13 byte solution:
```
eCf%hT2rS.nQ8
```
[Try it online!](http://pyth.herokuapp.com/?code=eCf%25hT2rS.nQ8&input=%5B%5B1%2C2%2C3%5D%2C%5B2%2C3%2C5%5D%2C%5B3%2C5%2C6%5D%2C%5B2%2C3%2C4%5D%2C%5B1%2C2%2C3%5D%5D&debug=0)
[Answer]
# Julia, 19.8 bytes
```
x->sort(symdiff(x...))
```
The source code is **22 bytes** long and qualifies for the **-10% bonus**. [Try it online!](http://julia.tryitonline.net/#code=ZiA9IHgtPnNvcnQoc3ltZGlmZih4Li4uKSkKCnByaW50KGYoZihbMSAyIDM7MiAzIDU7MyA1IDY7MiAzIDQ7MSAyIDNdKSkp&input=)
[Answer]
## JavaScript (Firefox 30-57), 62 bytes
```
(a,s=[])=>[for(b of a)for(c of b)s[c]^=c]&&[for(c of s)if(c)c]
```
Only works for positive integers. 64 bytes to work with zero too:
```
(a,s=[])=>[for(b of a)for(c of b)s[c]^=~c]&&[for(c of s)if(c)~c]
```
101 bytes to work with arbitrary floating-point numbers:
```
(a,m=new Map)=>[for(b of a)for(c of b)m.set(c,!m.get(c))]&&[for(b of m)if(b[1])b[0]].sort((a,b)=>a-b)
```
109 bytes to work with strings instead:
```
(a,m=new Map)=>[for(b of a)for(c of b)m.set(c,!m.get(c))]&&[for(b of m)if(b[1])b[0]].sort((a,b)=>(a>b)-(a<b))
```
[Answer]
# [GolfScript](http://www.golfscript.com/golfscript/), 5 - 10% = 4.5 bytes
Port of the CJam answer - reduce by symdiff, sort.
```
{^}*$
```
[Try it online!](https://tio.run/##S8/PSStOLsosKPkfHW1kpGBkZBTLFQ2iQRSEH/u/Oq5WS@V/wn8A "GolfScript – Try It Online")
] |
[Question]
[
This falls under the Code puzzles the best. Fastest way to render the numbers 1-million in a web browser. Preferably using PHP, but use what you must. Numbers must be more than one on a line in the web browser and must line wrap (the horizontal scroll bar must not be triggered).
rules:
1. use any loop construct that you want
2. No horizontal scrolling allowed
3. Count 1 - 1,000,000 (commas not needed, overshoot is OK)
4. Must be a language that displays results in a browser.
For my timer, I'm using:
```
$mtime = microtime();
$mtime = explode(" ",$mtime);
$mtime = $mtime[1] + $mtime[0];
$starttime = $mtime;
```
before the code and
```
$mtime = microtime();
$mtime = explode(" ",$mtime);
$mtime = $mtime[1] + $mtime[0];
$endtime = $mtime;
$totaltime = ($endtime - $starttime);
echo ("<br /><br /><b>Total count time:</b> ".$totaltime." seconds");
```
after the code.
[Answer]
# HTML
Just have a page with the numbers already in it! Encoded in base-36 for less characters and rendering time. 5 and a bit MB source so I'll just give you a little snippet:
```
<html><div style="width:100%; word-wrap:break-word;">1 2 3 4 5 6 7 8 9 a b c...
... pew2 pew3 pew4 pew5 pew6 pew7 pew8 pew9 pewa pewb pewc pewd pewe pewf pewg pewh pewi
pewj pewk pewl pewm pewn pewo pewp pewq pewr pews pewt pewu pewv peww pewx pex0 pex1 pex2
pex3 pex4 pex5 pex6 pex7 pex8 pex9 pexa pexb pexc pexd pexe pexf pexg pexh pexi pexj pexk
pexl pexm pexn pexo pexp pexq pexr pexs pext pexu pexv pexw pexx pf00 pf01 pf02 pf03 pf04
pf05 pf06 pf07 pf08 pf09 pf0a pf0b pf0c pf0d pf0e pf0f pf0g pf0h pf0i pf0j pf0k pf0l pf0m
pf0n pf0o pf0p pf0q pf0r pf0s pf0t pf0u pf0v pf0w pf0x pf10 pf11 pf12 pf13 pf14 pf15 pf16
pf17 pf18 pf19 pf1a pf1b pf1c pf1d pf1e pf1f pf1g pf1h pf1i pf1j pf1k pf1l pf1m pf1n pf1o
pf1p pf1q </div></html>
```
If you can be bothered, write this to an image with really small fontsize and it may increase rendering time!
Up to OP to figure out how to time this.
(This is barely a serious submission)
[Answer]
# PNG, 7874 bytes
This renders almost instantaneously in Firefox. There are 512 numbers on each line. Each number is displayed in base 16,777,216 as a single RGB pixel, with the numerical value of each being `65536 * R + 256 * G + B`. The horizontal scroll bar will not be triggered in Firefox when you view an image.
The image was created in Mathematica using
```
Image[
Partition[
Table[IntegerDigits[x, 256, 3], {x, 1, 1000000}],
512, 512, {1, 1}, {{255, 255, 255}}],
"Byte", Magnification -> 1]
```
, exported as a PNG, and optimized.
[Answer]
## HTML / Javascript
A semi-serious attempt. This is, in my opinion, one of the only sane ways to go about the problem. Render time is approximately 1-2 seconds for every browser I checked.
```
<html>
<head>
<title>Count</title>
<script type="text/javascript">
function load_me() {
var output_area = document.getElementById('output_area');
var str = '';
for(var i=1; i <= 1000000; i++) {
str += i + ' ';
}
output_area.innerText = str;
}
</script>
<style type="text/css">
#output_area {
height: 100%;
width: 100%;
}
</style>
</head>
<body onload="load_me()">
<textarea id="output_area"></textarea>
</body>
</html>
```
[Answer]
Using ruby and the web-framework sinatra:
```
# file: million.rb
require 'sinatra';get '/million.txt' do (1..(10*100*1000)).to_a.join("\n") end
```
Usage (requires ruby installed):
```
gem install sinatra
ruby million.rb
```
Then open `http://0.0.0.0:4567/million.txt` in any browser - took 636 ms hosted locally, opened in google-chrome.
Have fun ;)
] |
[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 6 years ago.
[Improve this question](/posts/8582/edit)
Write a code using HTML, JavaScript, jQuery to make the page go into infinite loop.
Restrictions:
No looping or control structures of javascript and jQuery allowed. You can only use alert, events, etc.
[Answer]
```
$($);
```
May not meet your conditions, but I like it. (And it does crash your browser.)
More information about this: [Why does $($) crash my page?](https://stackoverflow.com/questions/9585840/why-does-crash-my-page)
[Answer]
How about a meta refresh?
```
<meta http-equiv=refresh content=1>
```
I removed the quotation marks around the parameter values because code golf.
[Answer]
This reloads the page as soon as it loads:
```
<html>
<head>
<script>window.location=window.location</script>
</head>
</html>
```
Or you could bring up infinite alert boxes (until the user disables them):
```
<html>
<body onfocus="alert('')"></body>
</html>
```
[Answer]
This will reload the browser indefinitely:
```
location.reload()
```
(Unless the browser specifically blocks repeated reloads.)
] |
[Question]
[
Output this table:
| | | | | | | |
| --- | --- | --- | --- | --- | --- | --- |
| -2\* | -1\* | - | 0 | - | 1 | 2 |
| -1\* | 0 | 1 | - | 2 | 3 | 4 |
| 1 | 2 | 3 | - | 4 | 5 | 6 |
| 3 | 4 | - | 5 | - | 6 | 7 |
| 5 | 6 | - | 7 | - | 8 | 9 |
| 6 | 7 | 8 | - | 9 | 10 | 11 |
| 8 | 9 | 10 | - | 11 | 12 | 13 |
| 10 | 11 | - | 12 | - | 13 | 14 |
* You can output one string with two types of split, 1D string array with one type of split, or 2D string array
* If your language support mixed type then you can fill numbers in number cells(but not `-1*` and `-2*`)
* If your number type has one value `-` then you can use it in `-` cells. Otherwise they should be text `-`.
* This table comes from [here](https://codegolf.meta.stackexchange.com/a/25851/76323) but I removed 1st row and 1st column
* Shortest code wins
[Answer]
# JavaScript (ES6), 90 bytes
Returns a single string, using commas and line feeds as delimiters.
```
f=(n=7)=>~n--?[..."0024200"].map(j=>4-(n&2)&j?'-':v+["**"[++v+1]],v=34-n*7>>2)+`
`+f(n):''
```
[Try it online!](https://tio.run/##BcHRCsIgFADQ9z7Dh@nVFDNhMNB9iAiTNSNZ19HCx37dzimppXP9vI6vxPrYes@OoRvB@R9KOQelFNHaWKM1ieqdDlact5LhYGAoM5V0aiIQzkkQoolbjNfm7lYiH703IJbLIjJDmCjta8Wz7pva65NlBtD/ "JavaScript (Node.js) – Try It Online")
Or **78 bytes** without the asterisks:
```
f=(n=7)=>~n--?[..."0024200"].map(j=>4-(n&2)&j?'-':v++,v=34-n*7>>2)+`
`+f(n):''
```
[Try it online!](https://tio.run/##BcFBCsIwEADAu8/oodk1bggxUChs@hARGmojhropVnL063EmxxqP5fPavyTlsbaWGIQH5PAToulmjOmsdd5Z293NO@6QOXgC6R32eVKkxqr1pfLVk5yHEBzq@TTrBIKjUm0pcpRtNVt5QgLE9gc "JavaScript (Node.js) – Try It Online")
### How?
We iterate from \$n=6\$ to \$n=-1\$. The starting value of each row can be obtained with:
$$v\_n=\left\lfloor\frac{1}{4}(34-7n)\right\rfloor$$
There are 2 distinct row patterns:
$$\begin{cases}[v\_n,v\_n+1,\varnothing,v\_n+2,\varnothing,v\_n+3,v\_n+4]&n\in\{-1,2,3,6\}\\
[v\_n,v\_n+1,v\_n+2,\varnothing,v\_n+3,v\_n+4,v\_n+5]&n\in\{0,1,4,5\}\end{cases}$$
We can just test the penultimate bit of \$n\$ to distinguish them. We generate \$2\$ if it's set or \$4\$ otherwise and do a bitwise AND with the digit from the lookup string `"0024200"` according to its position.
[Answer]
# [Raku](https://github.com/nxadm/rakudo-pkg), 96 bytes
```
{map ->\i,\j {{j-3,j-2,$_&&j-1,!$_&&j-1,$_&&j,j+$_,j+1+$_}((153+>i)%%2)},<1 2 4 6 8 9 11 13>.kv}
```
Returns the output as a 2D list with `False` for the blanks.
[Try it online!](https://tio.run/##K0gtyjH7n1uplmb7vzo3sUBB1y4mUycmS6G6OkvXWCdL10hHJV5NLUvXUEcRxgDTOlnaKvFAwhBI1WpoGJoaa9tlaqqqGmnW6tgYKhgpmCiYKVgoWCoYGioYGtvpZZfV/i9OrFRIs/4PAA "Perl 6 – Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~47~~ ~~39~~ 37 bytes
```
Ｅ⁸Ｅ⁺Σ…68ι⊕Ｅ⁷Σ…432234λ⎇﹪λ⁴⁺⊖⊖÷λ⁴…*‹λ⁸-
```
[Try it online!](https://tio.run/##XY3BCoMwEER/JeS0lnhRaYUe9SIoCO0PhLhgYE0kUcGvT409VLqXXWZm36hROmUlhdA7bRbo5AylYHH1tHp4rRNUuyKsRjsDv5dcMJ0kgjVGOZzQLDicTw/B/rJFnmV5ceQpiSPYG52RbofODitZIMGKQz1ravzRrndjllpvesBvOlIuDbcD3qL30SxPk6c8dj1DCOlGHw "Charcoal – Try It Online") Link is to verbose version of code. Outputs a Charcoal array, i.e. each element on its own line and each row double-spaced from the previous. Explanation:
```
⁸ Literal integer `8`
Ｅ Map over implicit range
⁷ Literal integer `7`
Ｅ Map over implicit range
432234 Literal string `432234`
… Truncated to length
λ Current column
Σ Digital sum
⊕ Vectorised increment
⁺ Vectorised add
68 Literal string `68`
… Extended to length
ι Current row
Σ Digital sum
Ｅ Map over list
λ Inner value
﹪ Modulo
⁴ Literal integer `4`
⎇ If divisible then
- Literal string `-` otherwise
λ Current value
÷ Integer divided by
⁴ Literal integer `4`
⊖ Incremented
⊖ Incremented
⁺ Concatenated with
* Literal string `*`
… Truncated to length
λ Current value
‹ Is less than
⁸ Literal integer `8`
```
The program works by generating the following table, where the headers are generated from a list of differences:
| + | 1 | 5 | 8 | 10 | 12 | 15 | 19 |
| --- | --- | --- | --- | --- | --- | --- | --- |
| 0 | 1 | 5 | 8 | 10 | 12 | 15 | 19 |
| 6 | 7 | 11 | 14 | 16 | 18 | 21 | 25 |
| 14 | 15 | 19 | 22 | 24 | 26 | 29 | 33 |
| 20 | 21 | 25 | 28 | 30 | 32 | 35 | 39 |
| 28 | 29 | 33 | 36 | 38 | 40 | 43 | 47 |
| 34 | 35 | 39 | 42 | 44 | 46 | 49 | 53 |
| 42 | 43 | 47 | 50 | 52 | 54 | 57 | 61 |
| 48 | 49 | 53 | 56 | 58 | 60 | 63 | 67 |
Multiples of `4` are replaced with `-` while the remaining numbers are integer divided by `4` and then decremented twice, appending a `*` if this reduces them below zero.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 47 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
6L3-D>3FDÌ}D>DÌDÌ)εƵqbNèi¨Ƶ;S£ë3ô}'-.ý˜εD0‹i'*«
```
[Try it online.](https://tio.run/##JY0xCsJAEEWvsl1QfmQmu0kUIVWwEhtLsTBgkUrEOuABPIKdTSCtW1jYZCGNkEN4kTgbYXd4700xp8uhKI/DkKx1mGd6lbtblWcy5U1629lzsXF12dadXW7bh2u0e1ZBOHPvz723OX2vrzKYts0w7BgRCFq@QQwVCRqRGAlSKDMCCc6xgPKNBEmECcpH8iSDwRHU2IXJG2uwgfqv2N8Q5RicSBx35JV84HT/Aw)
**Explanation:**
```
6L # Push list [1,2,3,4,5,6]
3- # Decrease each by 3: [-2,-1,0,1,2,3]
D> # Duplicate it, and increase each by 1
3F } # Loop 3 times:
DÌ # Duplicate the top list, and increase each by 2
D>DÌDÌ # Three more duplicates with +1, +2, and +2 respectively again
) # Wrap all lists on the stack into a list
ε # Map over each inner list:
Ƶq # Push compressed integer 153
b # Convert it to binary: 10011001
Nè # Index the current map-index into it
i # If this is 1:
¨ # Remove the last item of the list
Ƶ; # Push compressed integer 212
S # Convert it to a list: [2,1,2]
£ # Split the list into parts of that size: [[a,b],[c],[d,e]]
ë # Else:
3ô # Split the list into triplets: [[a,b,c],[d,e,f]]
} # After the if-else:
'-.ý '# Intersperse the list of sub-lists with "-" delimiter
˜ # And flatten it to a single list again
ε # Map over each inner value:
D # Duplicate the current value
0‹i # Pop the copy, and if it's a negative integer:
'*« '# Append a "*"
# (after which the matrix is output implicitly as result)
```
[See this 05AB1E tip of mine (section *How to compress large integers?*)](https://codegolf.stackexchange.com/a/166851/52210) to understand why `Ƶq` is `153` and `Ƶ;` is `212`.
[Answer]
# [Python 3](https://docs.python.org/3/), ~~222~~ 216 bytes
```
r=[];z=(0,3,4,7);m=-1
for i in range(8):
r.append([]);s=i*2-(i+1)//4
for q in range(7):d=q-3-int(q>3)+int(q<2 and i in z);r[m]+=[s+d];r[m][m]="-"if(q in(2,4)and i in z)or q==3 and i in(1,2,5,6)else r[m][m]
print(r)
```
[Try it online!](https://tio.run/##TY1BDoIwFETX9hQNq35pRSiKoX4vQliQANpESils5PJo0ajJLGYx7419TLfeyGVxWJRqRrbnkqc8A9WhiEnbO6qpNtRV5tqwE@Rk43aVtY2pWVGCGlFvE8F0GEMUpWTjgeEHZJDXOAgptJnYcJEQruWc0MrUb/MMyhVdGWIxhnW59lcwEIFumVexhKfwN/cPiPJrYDFP@IEfobmPDf3wxDr/5GBZng "Python 3 – Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3.8/), 76 bytes
```
n=0
for r in b"(($"*2:n+=-4|r;print([r%c*'-'or(n:=n+1)for c in b""])
```
[Try it online!](https://tio.run/##K6gsycjPM7YoKPr/P8/WgCstv0ihSCEzTyFJSVRDQ0VJy8gqT9tW16SmyLqgKDOvRCO6SDVZS11XPb9II8/KNk/bUBOkJRmihZGRlZmVkVEpVvP/fwA "Python 3.8 (pre-release) – Try It Online")
This prints each row as its own list. The two bytestrings contain unprintable characters -- here's the code with their ASCII values shown:
```
n=0
for r in[21,40,40,36]*2:n+=-4|r;print([r%c*'-'or(n:=n+1)for c in[1,1,5,3,5,1,1]])
```
[Try it online!](https://tio.run/##K6gsycjPM7YoKPr/P8/WgCstv0ihSCEzL9rIUMfEAISMzWK1jKzytG11TWqKrAuKMvNKNKKLVJO11HXV84s08qxs87QNNUH6kkH6DHUMdUx1jIEYyIqN1fz/HwA "Python 3.8 (pre-release) – Try It Online")
The `r`'s in `[21,40,40,36]*2` correspond to the 8 rows, and the `c`'s in `[1,1,5,3,5,1,1]` to the 7 columns. They are chosen to make a "modulo table" producing the positions of the dashes, with a dash where `r%c==1` and `r%c==0` elsewhere.
```
c
1 1 5 3 5 1 1
r %--------------
21 | 0 0 1 0 1 0 0
40 | 0 0 0 1 0 0 0
40 | 0 0 0 1 0 0 0
36 | 0 0 1 0 1 0 0
21 | 0 0 1 0 1 0 0
40 | 0 0 0 1 0 0 0
40 | 0 0 0 1 0 0 0
36 | 0 0 1 0 1 0 0
```
Each non-dash position is filled with the number `n`, which is first incremented. Changes to `n` persist between rows, so before the start of each row we decrease `n` from the end of the previous row by substracting either 3 or 4, noting that it will increment by 1 before the first value is produced.
These deltas are encoded per-row by the `r`'s as `-4|r`, which produces `[-4,-3,-3,-3,-4,-3,-3,-3]`. Because this pattern repeats in 2 blocks of 4 for the 8 rows, as did the dash pattern, we write the `r`'s list as a four-entry list repeated twice, saving bytes.
Here are all the properties we needed the hardcoded `r`'s and `c`'s to satisfy:
```
-4|21 == -3
-4|40 == -4
-4|36 == -4
21%5 == 36%5 == 1
40%3 == 1
21%1 == 40%1 == 36%1 == 40%5 == 21%3 == 36%3 == 0
```
I found these with a brute-force search, and many other options were possible.
[Answer]
# [Scala](http://www.scala-lang.org/), 145 bytes
Port of [@xnor's Python answer](https://codegolf.stackexchange.com/a/263041/110802) in Scala.
---
Golfed version. [Try it online!](https://tio.run/##XY5BC4JAEIXv/opBCHZxFTetg7ZBP6CTdIoOm61i6WrjEoT5223NWzAD7328eUyfy1pO7fWucgNHWWkYHICbKqCxhkgs@wQOiPJ9zgxWurzQBE66MiBgmF4SQYswLVokuPMz9SRrzuJwnmhLPe@f0EF7Avz4g2ln20ytyRzhjLMNi@xaRYNGdiQX@6oguMqFCH9XPNWBaZcnRlX3yvVdG30shLjMpXScAEZnnL4)
```
var n=0;for(r<-Seq(21,40,40,36)++Seq(21,40,40,36)){n+= -4|r;println(Seq(1,1,5,3,5,1,1).map(c=>if(r%c==0){n+=1;n.toString}else"-").mkString(","))}
```
Ungolfed version. [Try it online!](https://tio.run/##bVDBSsQwFLz3K4aCkNBt2dXVw7IVvOtJPImHGNMlbpouSRRk7bfXlyZUD0KSx0xm3pvES2HENA2v70oGPAhtcS6AN9WhJ8CEO/gd7pwTX8@PwWl7eOE7PFkd0M5K4FM4WELrjAycJ3ivfWCXmxW267Svbjiq6l9@ccrFSQJa13Q9nxHyYtZ1gwNz2Nc0h@cMoARVi3qLb7jMzEmU/zAxqvRNL044Q6K9zQJAd7HTRSQp/2@zpeHmL9GEIX3BQo5QxiuUdZmpMdcTyYKxLM1v@mMysnKFkqfnRulYjMU0/QA)
```
object Main {
def main(args: Array[String]): Unit = {
var n = 0
val rs = List(21, 40, 40, 36) ++ List(21, 40, 40, 36)
val cs = List(1, 1, 5, 3, 5, 1, 1)
for (r <- rs) {
n += -4 | r
val result = cs.map { c =>
if (r % c == 0) {
n += 1
n.toString
} else "-"
}
println(result.mkString(", "))
}
}
}
```
] |
[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/223300/edit).
Closed 2 years ago.
[Improve this question](/posts/223300/edit)
Given a positive input \$n > 0\$, output the amout of two types based on their rarity. The two types are called \$A\$ and \$B\$, we know the followings:
* \$n\$ is a limited input and the maximum is \$nmax\$
* At the start \$B\$ is twice as rare as \$A\$
* As the presence of \$A\$ increade the rarity of \$B\$ decreases
* When \$n\$ = \$nmax\$, \$A\$ will be equal to \$B\$
* When \$n\$ is not \$nmax\$, \$A\$ cannot be equal to \$B\$
* The value of \$A\$ and \$B\$ cannot be decimal.
## Example
```
nmax = 10
n = 1, output = [1A, 0B]
n = 2, output = [2A, 0B]
n = 3, output = [2A, 1B]
n = 4, output = [3A, 1B]
n = 5, output = [3A, 2B]
n = 6, output = [4A, 2B]
n = 7, output = [4A, 3B]
n = 8, output = [5A, 3B]
n = 9, output = [5A, 4B]
n = 10, output = [5A, 5B]
```
Shortest code win.
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 25 bytes
```
m=>n=>[a=n/2+(n<m)|0,n-a]
```
[Try it online!](https://tio.run/##DcYxDoMwDAXQnVN4tJVCAyuYi1QMEZCqCL4rQF2gZw9M703hF7Z@/Xz3HDaMKWpatIW2r6B4Vo7RLHL6B/LQpWgrMUiprAnU3Po7zgkdGVFv2Gwei9neHLn0whCps3@6AA "JavaScript (Node.js) – Try It Online")
# [JavaScript (Node.js)](https://nodejs.org), 24 bytes
```
m=>n=>[b=n-(n<m)>>1,n-b]
```
[Try it online!](https://tio.run/##DcYxDoMwDAXQnVN4tAWpyByci1QMQJOqCL4rQCyoZ0@Z3puHc9in7fM9HOyVStayaoTG56hwjG6VGH0DN/Yl20YMUvKBQN1te6euha6KaDLstqTHYm/O7FthiITqV/4 "JavaScript (Node.js) – Try It Online")
[Answer]
# JavaScript (ES6), 28 bytes
Expects `(nmax)(n)`. Returns `[B,A]`.
(This is based on my current understanding of the task.)
```
m=>n=>[b=n/2-(n<m&~n)|0,n-b]
```
[Try it online!](https://tio.run/##DcY9DoJAEAbQnlNMZWaCK4stDBcxFPwtwcA3BIyN6NVXqveezbvZu21aXw7WDzFoXLSCVo9Wkd0do1wuP8jhr3BtHYNtDFLKCwKVp/5Mmgp9EqLOsNs83GYbOXDuhSFSJN/4Bw "JavaScript (Node.js) – Try It Online")
[Answer]
# Python, ~~266~~ 63 bytes
*And we're down to less than ~~half~~ ~~one-third~~ ~~one-quarter~~ ~~two-sevenths~~ one-quarter of my original*, so a lot less scuffed than anything I've put out, but it's a first answer:
```
def a(b,c):
m=(b<c)*(1-.5*(b%2))
return int(b/2+m),int(b/2-m)
```
Takes advantage of the fact that \$\frac {a+1} {b+1} < \frac a b\$, if \$a > b\$: after that, it's just handling evens and a few exception cases.
-58 due to Wasif and a lambda of `str(int(n))`, plus dropping of whitespace.
-24 due to Wasif and the lambda function 2.
-14 by Wasif again and more cleaner conditionals.
-5 due to Wasif *again* by dropping the last else.
-15/-1 to Dominic van Essen and Lyxal respectively.
-3 from Wasif (making a return) and -6 from Dominic Van Essen again.
-39 from pxeger due to input semantics, taking us under halfway.
-9 from pxeger and -7 from Lyxal, taking us under 100, by returning a tuple instead of a list.
-2 from Dominic Van Essen, also managing to fix an error in the process
-14 from Dominic Van Essen again, with a nice simplification.
So far, total bytes saved:
* Wasif: 104
* pxeger: 48
* Dominic Van Essen: 47
* Lyxal: 8
[Answer]
# [Husk](https://github.com/barbuz/Husk), ~~11~~ 10 bytes
```
Se≠¹÷2+¹←=
```
[Try it online!](https://tio.run/##ASYA2f9odXNr/21g4oKBwrnhuKP/U2XiiaDCucO3MivCueKGkD3///8xMA "Husk – Try It Online")
```
Se≠¹÷2+¹←= # full program:
Se≠⁰÷2+⁰←=²⁰ # here with implicit final arguments added for clarity;
+⁰ # add to n:
← # one less than
=²⁰ # 1 if n==m
# (in other words, subtract 1 from n if n==m),
÷2 # now integer divide by 2,
Se # and construct a 2-element list of the result together with
≠⁰ # the difference between itself and n
```
] |
[Question]
[
Convert a binary number (of any size) into a hexadecimal number.
**Input**
A *POSITIVE* binary number with just the `0`s and `1`s. A valid input will always match the following regex: `[0-1]+`. If the input is *not* a valid binary number, that is, anything not matching this regex, the output should be `0` or the program should exit, or error. The output does not need the leading `0x` nor does it need to be capitalized.
**Output**
The binary number converted to hexadecimal.
**Winning**
Original Code-Golf Rules, Lowest amount of bytes.
**Examples**
```
IN: [101]
OUT: [0x5] OR [5]
IN: [10000000010100100000]
OUT: [0x80520] OR [80520]
IN: [1010101]
OUT: [0x55] OR [55]
IN: [1111111111111111]
OUT: [0xFFFF] OR [FFFF] OR [0xffff] OR [ffff]
IN: [1012101]
OUT: [0]
IN: [a]
OUT: [0]
IN: [-1010101]
OUT: [0]
IN: [abcdef]
OUT: [0]
IN: [2]
OUT: [0]
```
[Answer]
# MY, ~~8~~ ~~6~~ 5 bytes
```
⍞PrH↵
```
[Try it online!](https://tio.run/##y638//9R77yAIo9HbVv//zc0AAA)
## How?
* `⍞` line of raw input
* `P` basify
* `r` convert from binary
* `H` convert to hex
* `↵` output
Errors if input isn't correct.
[Answer]
# Java, 126 119 117 110 104 Bytes
### Thanks to Jakob and Zacharý
```
class A{public static void main(String[]s){System.out.print(Long.toHexString(Long.parseLong(s[0],2)));}}
```
Expanded:
```
class A
{
public static void main(String[] s)
{
System.out.print(Long.toHexString(Long.parseLong(s[0], 2)));
}
}
```
[Answer]
# PHP, 25+1 bytes
```
<?=dechex(bindec($argn));
```
Run as pipe with `-F`.
or 27+1 bytes: (`-R`)
```
printf("%x",bindec($argn));
```
or 28+1 bytes: (`-F`)
```
<?=base_convert($argn,2,16);
```
or 30+1 bytes: (`-R`)
```
eval("printf('%x',0b$argn);");
```
[Answer]
# C, 168 bytes
```
i,l,k,n;f(char*s){char*o=malloc(l=strlen(s));for(i=n=0;i<l;n+=k<<i++)if((k=s[l-i-1]-48)&&k-1)return 0;for(i=o[--l]=0;n;n/=16)k=n%16,o[l-++i]=k>9?k+55:k+48;puts(o+l-i);}
```
[Try it online!](https://tio.run/##XYzRisIwEEXf/YoirMyYhm0WFTWd3Q@RPpRgNSROlqQ@id/eTaWg7hmYYe7cO0aejBkGW/rSlaw7MOc2LhPeHjPQpfU@GPCU@uiPDAlRdyGCJaZK29prFuTq2gqBtgNwlA5eWqkaudriYuGkwnjsr5GLagqGg5S@yWnW/Elqg474Q23KkINC2Ibc9@7HifV678Rqq3@vfYIg8lPU98FyX1xay4Cz26zIdDBXlZqjfm4TWR7byNv5Ua/KP8bTi/trct@HPw)
**Unrolled:**
```
i,l,k,n;
f(char *s)
{
// Allocate a string for the hexadecimal digits.
// The number of digits in the hex number is
// sure to be less or equal to that of binary.
char *o = malloc(l=strlen(s));
// Convert binary to decimal.
// The function returns zero without printing
// anything if there are extraneous characters.
for (i=n=0; i<l; n+=k<<i++)
if ((k=s[l-i-1]-48) && k-1) return 0;
// Convert decimal to hexadecimal.
for (i=o[--l]=0; n; n/=16)
k = n%16, o[l-++i] = k>9 ? k+55 : k+48;
// Print the number in hexadecimal.
puts(o+l-i);
}
```
[Answer]
# [Retina](https://github.com/m-ender/retina), ~~72~~ 70 bytes
```
A`[^01]
T`d`l`.(?!(....)*$)
T`d`23`b\d
T`d`4-7`b.\d
T`d`89L`b..\d
a|b
```
[Try it online!](https://tio.run/##K0otycxL/K@q4Z7w3zEhOs7AMJYrJCElISdBT8NeUUMPCDS1VDTBYkbGCUkxKWCmia55QpIelGNh6QPkgHiJNUlc//8bGhhyGRpAAZADIkCAyxDMA0qiAZCEEUgikUsXpiYxKTklNY3LCAA "Retina – Try It Online") Output is blank on error. Edit: Saved 2 bytes thanks to @PunPun1000. Explanation:
```
A`[^01]
```
Delete non-binary input.
```
T`d`l`.(?!(....)*$)
```
Convert all digits not in the correct position to `a`s and `b`s instead.
```
T`d`23`b\d
```
Add 2 to digits that follow a `b`.
```
T`d`4-7`b.\d
```
Add 4 to digits two after a `b`.
```
T`d`89L`b..\d
```
Add 8 to digits three after a `b`.
```
a|b
```
The `a`s and `b`s have done their job and can be deleted.
[Answer]
# CJam, 17 bytes
```
{2bGb{_9>'70?+}%}
```
Function that takes an array of bits as input.
[Test Version](http://cjam.aditsu.net/#code=q%3As%3Ai%7B2bGb%7B_9%3E'70%3F%2B%7D%25%7D~&input=1111111111111111)
```
{
2b e# Convert from base-2 to base-10.
Gb e# Convert from base-10 to base-16.
{ e# For each digit in the hex version...
_ e# Duplicate it.
9> e# Check if it's greater than 9.
'70? e# If it is, add a '7' (char) to the stack. If not, add a 0 (int).
+ e# Add the new item to the digit. Int + char => Increment char's ASCII value by int. (e.g '7' + 10 = 'A')
}%
}
```
If necessary, here's a version that checks for invalid input (**29 bytes**):
```
{_2,|$2,=1W?*2bGb{_9>'70?+}%}
```
[Test Version](http://cjam.aditsu.net/#code=q%3As%3Ai%7B_2%2C%7C%242%2C%3D1W%3F*2bGb%7B_9%3E'70%3F%2B%7D%25%7D~&input=1101)
It outputs 0 for an empty array and throws an exception for all other invalid input.
How validation works....
```
{
_2,|$ e# Get Logical OR of input array and [0,1], sorted.
2,= e# Does that equal [0,1]?
1W? e# If the arrays are equal add 1 to the stack, if not add -1.
* e# Repeat the input as many times as the number just added to the stack.
e# If the number is 1, the input is unchanged.
e# If it's -1 you get an error for an invalid number of repetitions.
...
```
[Answer]
# [R](https://www.r-project.org/), 34 bytes
```
function(x)as.hexmode(strtoi(x,2))
```
Returns `NA` for invalid input.
[Try it online!](https://tio.run/##K/qfpmCj@z@tNC@5JDM/T6NCM7FYLyO1Ijc/JVWjuKSoJD9To0LHSFPzf5qGkqGBoZImF5gBBUAREAECMBkwhHLQAFyJEVxJIoTShev7DwA "R – Try It Online")
[Answer]
# [6502 machine code](https://en.wikibooks.org/wiki/6502_Assembly) (C64), 100 bytes
```
00 C0 20 FD AE 20 9E AD 20 A3 B6 8D 1C C0 A0 00 84 FB 84 FC 29 03 AA D0 16 A2
04 A4 FB C0 FF D0 0E A4 FC A9 00 99 62 C0 A0 C0 A9 62 4C 1E AB A9 00 85 FE CA
30 1B 06 FE A4 FB E6 FB B1 22 C9 30 F0 F1 C9 31 F0 03 4C 99 AD A5 FE 09 01 85
FE D0 E2 A9 30 05 FE C9 3A 30 02 69 06 A4 FC 99 62 C0 E6 FC D0 B5
```
### [Online demo](https://vice.janicek.co/c64/#%7B"controlPort2":"joystick","primaryControlPort":2,"keys":%7B"SPACE":"","RETURN":"","F1":"","F3":"","F5":"","F7":""%7D,"files":%7B"binhex.prg":"data:;base64,AMAg/a4gnq0go7aNHMCgAIT7hPwpA6rQFqIEpPvA/9AOpPypAJliwKDAqWJMHqupAIX+yjAbBv6k++b7sSLJMPDxyTHwA0yZraX+CQGF/tDiqTAF/sk6MAJpBqT8mWLA5vzQtQ=="%7D,"vice":%7B"-autostart":"binhex.prg"%7D%7D)
Usage: `sys49152,"[input]"`, where `[input]` is your binary string, e.g. `sys49152,"10000000010100100000"`.
**Important:** When the program was loaded from disk (like in the online demo!), **issue a `new` command first**! This is because loading the program fiddles with some BASIC pointers and the machine thinks there's no RAM left for a string...
---
**Explanation** (commented disassembly listing):
```
00 C0 .WORD $C000 ; load address
20 FD AE JSR $AEFD ; check for comma
20 9E AD JSR $AD9E ; evaluate expression
20 A3 B6 JSR $B6A3 ; get string from expression
8D 1C C0 STA $C01C ; store input string length for CPY instruction
A0 00 LDY #$00 ; initialize counters to 0:
84 FB STY $FB ; read counter
84 FC STY $FC ; write counter
29 03 AND #$03 ; number of bits in first incomplete nibble
AA TAX ; -> to X register
D0 16 BNE .nibble ; branch to nibble decoding if not 0
.mainloop:
A2 04 LDX #$04 ; from here on 4 bits per nibble
A4 FB LDY $FB ; load read counter to Y
C0 04 CPY #$FF ; compare with input length (argument modified)
D0 0E BNE .nibble ; not yet done -> branch to nibble decoding
A4 FC LDY $FC ; load store counter
A9 00 LDA #$00 ; write NUL terminator
99 62 C0 STA .outbuf,Y ; to output string
A0 C0 LDY #$C0 ; load address of
A9 62 LDA #$62 ; output string
4C 1E AB JMP $AB1E ; and jump to string output routine
.nibble:
A9 00 LDA #$00 ; initialize value of nibble to zero
85 FE STA $FE ; store to temporary variable
.nibbleloop:
CA DEX ; decrement number of bits
30 1B BMI .nibbleout ; no bits left -> prepare for output
06 FE ASL $FE ; shift temporary variable left
A4 FB LDY $FB ; load read counter to Y
E6 FB INC $FB ; increment read counter
B1 22 LDA ($22),Y ; load next input character
C9 30 CMP #$30 ; compare with '0'
F0 F1 BEQ .nibbleloop ; if equal, handle next bit
C9 31 CMP #$31 ; compare with '1'
F0 03 BEQ .nibbleadd ; if equal, add that bit
4C 99 AD JMP $AD99 ; neither '0' or '1' -> type mismatch error
.nibbleadd:
A5 FE LDA $FE ; load temporary variable
09 01 ORA #$01 ; set lowest bit
85 FE STA $FE ; store temporary variable
D0 E2 BNE .nibbleloop ; handle next bit
.nibbleout:
A9 30 LDA #$30 ; load character '0'
05 FE ORA $FE ; combine with value from temporary variable
C9 3A CMP #$3A ; result smaller than 0x39 ('9') ?
30 02 BMI .nibblestore ; then store that
69 06 ADC #$06 ; otherwise add offset to get in range 'a'-'f'
.nibblestore:
A4 FC LDY $FC ; load write counter
99 62 C0 STA .outbuf,Y ; write to output string
E6 FC INC $FC ; increment write counter
D0 B5 BNE .mainloop ; back to main loop
.outbuf: ; "BSS", output string is stored from here
```
**Remarks:**
* Input validation is fully implemented (and takes quite a few bytes, otherwise it would be possible to directly output each decoded nibble without temporary storage)
* I took the liberty to interpret "*any length*" as "*any length my C64 system can read from a command line as a string*", which is quite limited ... 69, or if you abbreviate `sys` with `sY` 70 "bits", because the whole command line is limited to 80 characters ... hope this is acceptable :)
[](https://i.stack.imgur.com/eVUrq.png)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~7~~ 6 bytes
```
CbQ*Ch
```
[Try it online!](https://tio.run/##MzBNTDJM/f/fOSlQyznj/39DAygwBEIDCA8A "05AB1E – Try It Online")
[Error case](https://tio.run/##MzBNTDJM/f/fOSlQyznj/39DA0MjIAYA "05AB1E – Try It Online")
It's my first try ever to a Code Golf, advices welcomed!
Handles error cases \o/
The idea is to make the conversion from base 2 to base 10, and back to base 2.
Compare the result with the initial input, if it's not the same, then the conversion have failed.
```
1012101 => 0
a => empty
-1010101 => 0
abcdef => empty
2 => 0
```
### Explanation
```
CbQ*Ch
C # convert input from base 2 to base 10
b # ...and back to 2
Q # 1 if the full conversion back and return equals the input, else 0
* # multiply to get 0 if error case
C # convert corrected input from base 2 to base 10
h # convert it to base 16
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), 27 25 bytes
```
->b{'%x'%Integer('0b'+b)}
```
[Try it online!](https://tio.run/##bU09D4JADN35FQ2GnEYx4GgCmwOLLjoRBnoUZDkIHwkG@O14d17UGF@T19e@17Tp8bHkweKGODJnYE4kOiqoWTMP2RY38xIz3/PZDmQzkLMihddel5Y/MPbB2Kki9yufIs8oV@qgyGPJnlJ@h6yCCScLJOq@a8GOzkdYjTjbeodUlEKrT@Jyu6pIHmNiUg21vCc4DZzqrqwEBCHQ/ysyJySy91NLDssT "Ruby – Try It Online")
-2 bytes thanks to histocrat.
Inputs and outputs strings.
[String#to\_i](https://ruby-doc.org/core-2.4.1/String.html#method-i-to_i) vows to never throw an exception, returning `0` for many invalid inputs. That would be fine, except for this property:
`Extraneous characters past the end of a valid number are ignored.`
Meaning that `1012101` is read up to the 2 and interpreted as `101` (or 5), which is no good. We can use the stricter `Integer()` instead, which throws an exception for any number that is not binary. It lets through negative numbers, so we need to invalidate those by prepending `0b` to the input. `0` as input returns `0`, which is within the specification.
[Answer]
# [Tcl](http://tcl.tk/), 66 bytes
```
proc H b {expr {[regexp ^\[01\]+$ $b]?[format %x [scan $b %b]]:0}}
```
[Try it online!](https://tio.run/##XY4xCsMwDEX3nOIPyVQKdsYuXXMHxwXZdbokjXEcCBif3bVCu/QNQl9PCEU7l@LDajHAILnDByQV3Kt2eIxKyFFfWrRG39W0hoUiugNqs/SuQ3RG65vIucwLeT4ghYQUX2rgwkCeqco/WBALwvW3Q8Y@3YQ@IzV@jxvUwB80uXwA "Tcl – Try It Online")
[Answer]
# [Rust](https://www.rust-lang.org/), ~~58~~ 57 bytes
Saved one byte using 8 bit int
```
|n:&str|format!("{:x}",u8::from_str_radix(n,2).unwrap());
```
Ungolfed
```
fn main() {
let bin = "101";
println!("{:x}", u8::from_str_radix(bin, 2).unwrap()); // 5
}
```
[Try it online!](https://tio.run/##HctNCoAgEEDhvaeYXClEfxCE0lnCqECoSUalIDy7RW/5waPoQ84bwmEsCgkPg699DTBbhBF427Rc/@jIYtixEPxRd@JlHJTa6DwmH2gis9hbfE/ZySriRcYJKTXUNfQs5fwC "Rust – Try It Online")
[Answer]
# Python 3, ~~52~~ ~~29~~ 26 bytes
```
print(hex(int(input(),2)))
```
[Answer]
# [Stacked](https://github.com/ConorOBrien-Foxx/stacked), 24 bytes
```
[:\'1|0'-#'0=\unbin*hex]
```
[Try it online!](https://tio.run/##XUtLCoMwEN3nFA@6mKRVUJdCofdQF9FElFqVqtCFePV0oi2FvmGG95tp1tXdGueyNKd4jSg8UXTNl75s@3NjX4W7pbUQkuIoJvD9gKU/Hru9j2d/OMLkCDVv@OvqsjK2ZpKQQiaAFDUCUeChR0hJ27ah7cdlBjOueT0s89dQCjkCNENnYNppxNN2Vk8WRLRmUhWEEPzGrQv4yb0B "Stacked – Try It Online")
[Answer]
## [Dyvil](https://github.com/Dyvil/Dyvil), 32 Bytes
```
s=>Int.parseInt(s,2).toHexString
```
Pretty much self-explanatory. Throws a `NumberFormatException` for invalid inputs. Output without `0x`.
[Answer]
# Javascript (ES6) ~~50~~ ~~45~~ 39 bytes
```
h=
s=>isNaN(n=+('0b'+s))?0:n.toString(16)
```
```
<input id="i" type="text" onchange="o.innerHTML=h(i.value)"><pre id="o"></pre">
```
with thanks to Shaggy 6 bytes less. Or for a 26 byte version that returns 'NaN' instead of '0' on error:
```
s=>+('0b'+s).toString(16)
```
`'0b'` was introduced as a binary number prefix in ES6.
[Answer]
# [Python 2](https://docs.python.org/2/), 27 bytes
```
lambda s:hex(int('0b'+s,2))
```
[Try it online!](https://tio.run/##XU/BCoMwDD3brwjs0BYd1B4FL7vvC7YdWm1R2Kq0OejXd7XTMfYCLy/JCyTzisPkZLTtPT7VS/cKQjOYhY0OGRWalqGSnEc0AQO0cCMFrUVNq5x3pMZGG/ZBjo/@w2GQh0FlPv/uKN31xmYpE5PiBNfRmSbVQm@2PBKXryx39SDETh4QRgf54rSCfm1g9ukfsAw5KczSmRmPHhXAjPeT5zS@AQ "Python 2 – Try It Online")
We invalidate inputs like `0b1010` or `-1010` by prefixing `0b` ourselves — because `0b0b1010` and `0b-1010` are invalid base 2 literals in Python.
[Answer]
# [Perl 6](http://perl6.org), 19 bytes ( = 18 + 1 for "-p" )
`perl6 -pe '$_=:2($_).base: 16'`
Nothing creative. The `:2(string)` construct takes the `string` and interprets it as a number in base 2. (This works for arbitrary bases up to base 36.) The `base` method takes a number and gives a string representation in the given base.
Due to `-p`, it loads one line from stdin at a time, expecting each to contain one number. If you feed it something that's not valid binary number, you get an error and the program ends.
[Answer]
# Javascript, 28 bytes
```
x=>eval("0b"+x).toString(16)
```
`eval`s `x` with a `0b` in front of it, turning it into a binary literal. Binary literals error out on non binary values of `x`. `.toString(16)` turns `x` into a hexdecimal.
[Answer]
# [Perl 5](https://www.perl.org/), 30 + 1 (`-n`) = 31 bytes
```
printf"%x",!y/01//c&&oct"0b$_"
```
[Try it online!](https://tio.run/##K0gtyjH9/7@gKDOvJE1JtUJJR7FS38BQXz9ZTS0/uUTJIEklXun/f0Mg@JdfUJKZn1f8X9fXVM/A0OC/bh4A "Perl 5 – Try It Online")
[Answer]
## REXX, 15 bytes
```
say b2x(arg(1))
```
[Answer]
# Common Lisp, 48 bytes
```
(format t"~X"(parse-integer(read-line):radix 2))
```
[Try it online!](https://tio.run/##S87JLC74/18jLb8oN7FEoUSpLkJJoyCxqDhVNzOvJDU9tUijKDUxRTcnMy9V06ooMSWzQsFIU/P/f0MDKDAEQgMIDwA)
[Answer]
# Julia, 24 bytes
```
f(x)=hex(parse(Int,x,2))
```
[Try it online!](https://tio.run/##yyrNyUw0/f8/TaNC0zYjtUKjILGoOFXDM69Ep0LHSFPzf0FRZl5JTp5GmoaSoYGhkqYmF6qIAUT0PwA "Julia 0.5 – Try It Online")
[Answer]
# [Bash](https://www.gnu.org/software/bash/), 19 bytes
```
printf %x $((2#$1))
```
[Try it online!](https://tio.run/##S0oszvj/v6AoM68kTUG1QkFFQ8NIWcVQU/P///@GBlBgCIQGEB4A "Bash – Try It Online")
[Answer]
# ><>, ~~84~~ 82 Bytes
Improved somewhat. Probably still improvable.
```
l&1>:}*{$}2\~-?\02.
~~&\?&:-1&*/1l+<
>:f1+%:}\
\?:,+1f-/.47r~
)a:;!?ln/?
.47o+*b5/
```
Old version:
```
1l&>:}*{$}2\
~~&\?&:-1&*/l +<
>:f1+%:}-f1\1-?/
\? :,+/r~
n/?)a:;!?l <
5/.4co+*b
```
~~I'll work on improving it later, see if I can get rid of that big chunk of whitespace.~~
### How it works:
(This is for the old version, new version works the same but with loops in different positions)
Implicit input, assumed to be a series of bits such as '1,1,1,0,0', with the ones place on the right, as normal.
```
l&1
```
Store the length in the registry; push 1 to the stack. The 1 will record which place we are on in the binary number.
```
>:}*{$}2\
\?&:-1&*/
```
Replace each bit with the value it represents. For example, 1,1,1,0 goes to 8,4,2,0.
```
~~&
```
Delete the counter and position-measurer.
```
/l +<
\1-?/
```
Sum the stack. Results in the number that was represented in binary.
```
>:f1+%:}-f1\
\? :,+/
```
Convert this to hexadecimal, which unfortunately reverses it and leaves a trailing 0. For example, 28 becomes 12, 1, 0.
```
/r~
```
Remove the trailing zero and un-reverse it.
```
n/?)a:;!?l <
5/.4co+*b
```
This is all for printing. If the value is <10, just print it normally. Otherwise, add 55 and print the ascii character of this number.
[Answer]
# Lua, ~~43~~ 40 bytes
```
print(("").format("%x",tonumber(...,2)))
```
I think it explains itself. Parses from base 2 to decimal then formats it to hex.
If it is not binary input it will simply error (tested with Lua 5.2,5.3).
[Answer]
# [><>](https://esolangs.org/wiki/Fish), 50 bytes
```
{:?v~
!v0>}l4%?
r
4<]nv?)9:+++*2}*4}*8[
+"W"<.33o
```
[Try It Online](https://tio.run/##S8sszvj/v9rKvqyOS7HMwK42x0TVnkuhiMvEJjavzF7T0kpbW1vLqFbLpFbLIppLWylcyUbP2Dj/////umX/Df4bAjEqNISLIskBAA)
Complies with the question by erroring on invalid input, but as it always ends with an error anyway, this is a bit tongue in cheek.
### How It Works
```
{:?v~ Pops leading 0s
...
...
!v0>}l4%? Adds leading 0s until the length of the binary is divisible by 4
r And reverses the input
...
... Repeatedly take the last 4 digits of the binary
4<]nv?)9:+++*2}*4}*8[ Calculate the value of those digits and print the hexadecimal value
+"W"<.33o If the value is above 9, print the appropriate letter
```
[Answer]
# [Kotlin 1.1](https://kotlinlang.org), 92 bytes
## Submission
```
fun r(i:String):String{return if(i.matches(Regex("[01]+")))i.toLong(2).toString(16)else "0"}
```
## Beautified
```
fun r(i: String): String {
return if (i.matches(Regex("[01]+"))) { // If it is valid
i.toLong(2) // Convert to Long
.toString(16) // Return as hex
} else { // Otherwise
"0" // Return 0
}
}
```
## Explanation
* The number is checked to be valid by the regex
* Kotlin to and from string methods are used to convert the string
**Unfortunately this does not run on TryItOnline, as it uses newer Kotlin features**
] |
Subsets and Splits