text
stringlengths 180
608k
|
|---|
[Question]
[
Given an ASCII representation of a piece of string, determine its length.
# Input
An multi-line ASCII rendering of a piece of string, which runs from top to bottom, with one 'node' (corner) on each line of input. The delimiter may be assumed to be `CR`, `LF`, `CRLF`, or `LFCR`. Input may be accepted from STDIN, Command Line Argument, Function Parameter, or whatever daft method your language of choice necessitates if none of the prior are applicable.
```
#
#
#
####
##
##
#
##
#
```
Each line in the context of the previous tells you the position of one of the nodes on the string. The first line always has exactly one hash `#`, so the position is trivially found. Each following line has a hash '#' on the node itself, and on all calls which must be included to make the string 'complete' (attached to itself). All positions will be between 0 and 9 inclusive, but the difference is what realy matters.
For example, the string defined by the sequence `1, 3, 6, 5, 1, 3, 4` has the following nodes:
```
#
#
#
#
#
#
#
#
#
```
Which we must join up on a line by line basis starting from the top (nodes marked with `X` for clarity, they will be hashes in actual imputs). This means, the first line has no hashes, and each following line has exactly as many hashes as are rquired to 'connect' the previous node to the current with hashes. This can be thought of as putting a hash in every space between the two nodes (on the lower line) and then removing any that appear on the line above. Example:
```
X
#X
##X
X
X###
X
X#
##X
X
```
There will be no fewer than 2 lines, and no more than 100. The input will be padded with spaces to form a rectangle of width 10 (excluding the line delimiters). You may require a trailing new-line be present or absent, but declare any such requirements in your answer.
# Computing the Arc Length
You must output the arc length of this string. You compute the arc length by taking the distances between each consequtive nodes. The distance between one node and the next is `sqrt(d^2 + 1)` where `d` is the difference in position (that is, the current position minus the previous). For example, the sequence `4, 8, 2, 3, 4, 4` has differences `4, -6, 1, 1, 0`, which gives distances (rounded to 2 dp) `4.12, 6.08, 1.41, 1.41, 1` by squaring, adding one, and square-rooting. The arc length is then the sum of these distances, `14.02`.
You *must* reduce the result of the square-root to 2 decimal places before summing (this is to allow sqrt tables and make answers consistent/comparable across systems; see below).
Using the input example at the top`
```
# 2 -1 1.41
# 1 +0 1.00
# 1 +4 4.12
#### 5 -5 5.10
## 0 +3 3.16
## 3 -2 2.24
# 1 +2 2.24
## 3 -1 1.41
# 2
20.68 (total)
```
# Output
You must output the arc length as exactly one number, or a decimal string represenation with 2 decimal places of precision. Numerical output must be rounded, but I'm not going to quibble about minute floating point inaccuracies.
# SQRT Table
This is a table of the rounded squareroots you must conform to. You can either use this table itself, or verify that your system conforms to the results.
```
1 1.00
2 1.41
5 2.24
10 3.16
17 4.12
26 5.10
37 6.08
50 7.07
65 8.06
82 9.06
```
Powershell to produce this table:
```
0..9 | % {"" + ($_ * $_ + 1) + " " + [System.Math]::Sqrt($_ * $_ +1).ToString("0.00")}
```
# Test Cases
Input:
```
#
#
#
####
##
##
#
##
#
```
Output: `20.68`
Input:
```
#
###
####
#
###
#
###
####
#
#
##
########
#
###
######
```
Output: `49.24`
Input:
```
#
##
######
#
####
#
######
#
########
#
####
####
```
Output: `44.34`
# Test Code
A larger test case and a C# solver and example generator can be found [as a Gist](https://gist.github.com/VisualMelon/1a8cbb79c52a156657fe214544f29f97).
# Victory Criterion
This is code-golf, the shortest code will win.
[Answer]
# JavaScript (ES6), 158 bytes
*-1 byte thanks to @VisualMelon*
```
s=>s.split`
`.map(s=>(s=s.replace(/./g,(m,i)=>m>" "?i:""),n=s[0]>n?s.slice(-1):s[0]),n=p=0).reduce((t,v,i)=>(r=i&&t+(((p-v)**2+1)**.5*100+.5|0)/100,p=v,r),0)
```
Output is sometimes not exact (`0.999` instead of `1`) due to floating-point imprecision, but rounding was done part-way through the steps in order to match the square root table.
## Test Snippet
Note that trailing spaces on each line are ignored, so they can be omitted from the input.
```
f=
s=>s.split`
`.map(s=>(s=s.replace(/./g,(m,i)=>m>" "?i:""),n=s[0]>n?s.slice(-1):s[0]),n=p=0).reduce((t,v,i)=>(r=i&&t+(((p-v)**2+1)**.5*100+.5|0)/100,p=v,r),0)
```
```
<textarea id=I rows=15 cols=12></textarea><br>
<button onclick="O.value=f(I.value)">Run</button> <input id=O disabled>
```
] |
[Question]
[
**This question already has answers here**:
[Fibonacci function or sequence](/questions/85/fibonacci-function-or-sequence)
(334 answers)
Closed 7 years ago.
**Background of Lucas Numbers**
The French mathematician, Edouard Lucas (1842-1891), who gave the name to the Fibonacci Numbers, found a similar series occurs often when he was investigating Fibonacci number patterns.
The Fibonacci rule of adding the latest two to get the next is kept, but here we start from 2 and 1 (in this order) instead of 0 and 1 for the (ordinary) Fibonacci numbers.
The series, called the Lucas Numbers after him, is defined as follows: where we write its members as Ln, for Lucas:
[](https://i.stack.imgur.com/vQv7p.png)
**Challenge**
**Input**
0 < x < ∞
The input will be a positive integer starting at 0.
**Output**
The output must be a positive integer.
**What to do?**
Add the Fibonacci numbers to the Lucas numbers.
You will input the index.
The output will be the addition of the Lucas and Fibonacci numbers.
**Fibonnaci formula:**
>
> F(0) = 0,
>
> F(1) = 1,
>
> F(n) = F(n-1) + F(n-2)
>
>
>
**Lucas formula:**
>
> L(0) = 2,
>
> L(1) = 1,
>
> L(n) = L(n-1) + L(n-2)
>
>
>
**Who wins?**
Standard Code-Golf rules apply, so the shortest answer in bytes wins.
**Test-cases**
>
> A(0) = 2
>
> A(1) = 2
>
> A(5) = 16
>
> A(10) = 178
>
> A(19) = 13,530
>
> A(25) = 242,786
>
>
>
[Answer]
# C, 33 bytes
```
A(n){return n<2?2:A(n-1)+A(n-2);}
```
] |
[Question]
[
**This question already has answers here**:
[String.prototype.isRepeated](/questions/37851/string-prototype-isrepeated)
(20 answers)
Closed 7 years ago.
>
> A string is called a "prime string" if it can't be written as a concatenation of more than one of the same string.
>
>
>
Your task is to write a program that, given a sequence of letters of length *N* (5 < *N* < 100), determines if it is prime or not.
## Examples
Input: `AABBAA`
Output: `not prime`, `false`, `0`, etc.
Input: `FDFJKEHKLJHDSUS`
Output: `prime`, `true`, `1`, etc.
Uppercase and lowercase letters count as the same letter.
Remember, this is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the code with the smallest number of bytes wins.
## Leaderboards
Here is a Stack Snippet to generate both a regular leaderboard and an overview of winners by language.
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 leaderboard snippet:
```
# [><>](http://esolangs.org/wiki/Fish), 121 bytes
```
```
var QUESTION_ID=94238,OVERRIDE_USER=12537;function answersUrl(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 commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
```
```
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
```
```
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>
```
[Answer]
# Ruby, 16 + 1 (`n` flag)` = ~~36~~ 17 bytes
Basically the prime-checking regex for unary numbers. Probably shorter in Retina. If you want a newline after the output, add the newline for 1 bytes.
Edited to a shorter version only for the sake of posterity, since there's not much point in answers to dupe questions.
```
p ! ~/^(.+)\1+$/
```
] |
[Question]
[
**Input:**
A grid of varying size only containing numbers in the range `00-99`, the following four characters: `^`; `>`; `v`; `<`, and spaces to fill (and new-lines of course).
**Output:**
The result of the sum (integer) when you follow the path.
**How does this work?**
You start at the arrow with the highest number, and follow the path the arrows point to.
For each of the four arrows we'll do a different arithmetic calculation:
* `>` = Addition (+);
* `<` = Subtraction (−);
* `^` = Multiplication (\* or × or ·);
* `v` = Real / Calculator Division (/ or ÷);
(NOTE: The symbols between parenthesis are just added as clarification. If your programming language uses a completely different symbol for the arithmetic operation than the examples, then that is of course completely acceptable.)
**Challenge rules:**
* You can choose the input (to some extent). A string-array would be most logical I think, but a symbol/newline-separated single string is also fine. (Full functions as input that are simply executed in the actual code snippet aren't allowed!)
* Trailing spaces for the input are optional.
* Numbers `0-9` will have a leading `0` so all numbers plus arrow are of an equal three-character length.
The number & arrow will always have the following format: `DDA` (`D` being a digit; `A` being one of the four arrows).
* You use the current value with the previous arithmetic operation (the example below explains this better).
* The final arithmetic operation can be ignored because of the rule above.
* It is possible to have *DDA*'s in the input-grid that aren't being used in the path to the resulting sum.
* There won't be any test-cases for arrows that form a loop.
* There won't be any test-cases for dividing by 0.
* There won't be any test-cases where dividing creates a decimal sum-result. You only have to worry about integers.
* ***EDIT: Since there weren't any answer yet, I decided to change the grids slightly to perhaps make it easier. I know this is usually not recommended to do with challenges, but since no answers were given yet, I think this will make it slightly easier, giving more (/any) answers:***
~~The spaces between de *DDA*'s are random. There could even be no spaces in between at all.~~ All *DDA*'s and spaces are grouped per three. Also, it is possible to have no spaces between *DDA*'s at all.
**Example:**
*Input:*
```
94> 66v
05v 08<
43>
03> 00^
```
*Path it follows:*
```
Path it follows | Current sum value
________________________________________
94> | 94 (highest value)
66v | 160 (+)
08< | 20 (/)
05v | 15 (-)
03> | 5 (/)
00^ | 5 (+)
43> | 215 (*)
'>' after 43 is ignored because it's the last number
```
*Output:* 215
**General Rules:**
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest answer in bytes wins.
Don't let code-golf languages discourage you from posting answers with non-codegolfing languages. Try to come up with an as short as possible answer for 'any' programming language.
* [Standard rules apply](http://meta.codegolf.stackexchange.com/questions/2419/default-for-code-golf-program-function-or-snippet/2422#2422) for your answer, so you are allowed to use STDIN/STDOUT, functions/method with the proper parameters, full programs. Your call.
* [Default Loopholes](http://meta.codegolf.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) are forbidden.
* If possible, please add a link with a test for your code.
* Also, please add an explanation if necessary.
**Test cases:**
```
94> 66v -> 215
05v 08<
43>
03> 00^
77> 80v55^02< -> -19
20> 14^
22>11>15>80>14v -> -16
18^17> 10v
00^ 90v43^02v
07^11<15<22v01<
99>98>97>96>95>94v -> 102
93>92> 91v 03<
```
[Answer]
# Python 2, ~~409~~ ~~390~~ 377 bytes
```
def f(p):
p=map(lambda s:map(lambda d:d==3*(' ',)and(0,-1)or(int(d[0]+d[1]),'><^v'.index(d[2])),zip(s[::3],s[1::3],s[2::3])),p);x,y=max([(x,y)for x in range(len(p[0]))for y in range(len(p))],key=lambda(x,y):p[y][x][0]);r=o=0
try:
while 1:
1/(y*x>=0);d=p[y][x]
if-1<d[1]:r=eval('r%sd[0]'%'+-*/'[o]);o=d[1];a=(-(o==1),1)[o<1];b=(-(o==2),1)[o>2]
x+=a;y+=b
except:print r
```
The second and third indent levels are a raw tab and a raw tab plus a space, respectively. Markdown mangles the raw tabs, so they've been replaced by two spaces.
Ungolfed:
```
def follow(path):
# Split path's strs into DDAs ((0, -1) for blank, else (int, int))
path = map(
lambda s: map(
lambda dda: (0, -1) if dda == (' ', ' ', ' ') else (int(dda[0] + dda[1]), '><^v'.index(dda[2])),
zip(s[::3], s[1::3], s[2::3])
),
path
)
# Find highest DDA
x, y = max([(x, y) for x in range(len(path[0])) for y in range(len(path))], key=lambda (x, y): path[y][x][0])
result = 0
op = 0 # addition
try:
# Keep following the path until we get an IndexError
while True:
if y < 0 or x < 0: raise IndexError
dda = path[y][x]
if dda[1] != -1:
# It's not empty - do the operation & change direction
const = dda[0]
result = eval('result %s const' % '+-*/'[op])
op = dda[1]
dx = 1 if op == 0 else -1 if op == 1 else 0
dy = 1 if op == 3 else -1 if op == 2 else 0
# Move to the next thing
x += dx
y += dy
except IndexError:
# We've exited the path - return
print result
```
[Ideone it! (all test cases)](http://ideone.com/IdpEEt)
[Answer]
## Python 2, 449 bytes
```
i=input();p,d,a,o,l=[-1,0],">",0,"+",0
for y in range(len(i)):
for x in range(len(i[0])):
if i[y][x]in"><^v":
v=int(i[y][x-2]+i[y][x-1])
if v>l:l=v;p=[x-2,y]
while 1:
if d==">":p[0]+=1
if d=="<":p[0]-=1
if d=="^":p[1]-=1
if d=="v":p[1]+=1
try:
c=i[p[1]][p[0]]
if c in"><^v":
d=c
if p[0]<0 or p[1]<0:1/0
a=eval(str(a)+o+str(int(i[p[1]][p[0]-2]+i[p[1]][p[0]-1])));o={">":"+","<":"-","^":"*","v":"/"}[c]
except:print a;break
```
This takes an array of strings as input
Ungolfed:
```
pointer = [-1,0]
dir = ">"
output=0
operation="+"
largest = 0
for y in range(len(input)):
for x in range(len(input[0])):
if input[y][x] in "><^v":
value = int(input[y][x-2]+input[y][x-1])
if value > largest: largest = value; pointer = [x-2, y]
while 1:
if dir==">":pointer[0]+=1
if dir=="<":pointer[0]-=1
if dir=="^":pointer[1]-=1
if dir=="v":pointer[1]+=1
try:
current = input[pointer[1]][pointer[0]]
if current in "><^v":
dir = current
value = int(input[pointer[1]][pointer[0]-2]+input[pointer[1]][pointer[0]-1])
if pointer[0]<0 or pointer[1]<0:1/0
output=eval(str(output)+operation+str(value))
if current==">":operation="+"
if current=="<":operation="-"
if current=="^":operation="*"
if current=="v":operation="/"
except:
print output;break
```
] |
[Question]
[
**This question already has answers here**:
[Determine whether strings are anagrams](/questions/1294/determine-whether-strings-are-anagrams)
(162 answers)
Closed 7 years ago.
# Inspired by [Input ∩ Source Code](https://codegolf.stackexchange.com/q/89400/48934).
---
# Task
* Your task is to determine whether the input is a permutation of the source code.
# Input
* A string. Input is flexible; it should be able to handle the character encoding used for the source code.
# Output
* You may only have two possible outputs, one when the input is a permutation of the source code, and one when it is not. Those outputs maybe be of any length (including 0) but must be distinct, consistent, and deterministic.
# Specs
* Similar to [quine](/questions/tagged/quine "show questions tagged 'quine'") challenges, the program/function may not read its own source code and 0-byte solutions are not allowed.
# Example
If your source code is `ppcg`, then an input of `cpgp` or `ppcg` would be a permutation of the source code while `cpg` or `cggp` or `caqp` or `cpaqr` would not be.
[Answer]
## Python 2.7, ~~135~~ 112 bytes
```
print sorted(list(input()))==sorted(list('\''*7+'\\'*3+'print sorted(list(input()))==sorted(list(*7+*3+*2))'*2))
```
] |
[Question]
[
Write some code that takes a single string as input and outputs MSB-set aligned ASCII.
Only ASCII characters less than 128 (0x80) will be in the input. The output format is generated as follows:
* For each character convert it to its binary representation, remove the MSB (always `0` in the input) and then add a delimiter-bit (`X`) to both ends. The value will now be 9 bits long and both begin and end in `X`
* Output each character in order, MSB to LSB, making sure that the MSB of each output byte is either `1` or `X`
* If the MSB of the next byte would normally be `0`, output the fewest `.`s needed between two consecutive `X`s to align the MSB with a `1` or `X`
* Output the data as binary digits, with `X` for each delimiter and `.` for each padding bit
* At the end of the data, write a `.` after the last `X`, then as many `.`s as necessary to complete the last byte
* Separate each byte (group of 8 digits) with a single whitespace character (space, tab, newline, etc.)
* A whitespace character at the end of the last output line is optional
* Empty input must produce `........` as the output
* Your code must work on any length strings that your language can handle and at least 255 characters
Input: `Hello, World!`
```
Bytes -> Delimited -> * Output Start and End of each character
01001000 X1001000X X1001000 'H'
01100101 X1100101X XX110010 'e' 'H'
01101100 X1101100X 1X.X1101 'l' 'e'
01101100 X1101100X 100XX110 'l' 'l'
01101111 X1101111X 1100X.X1 'o' 'l'
00101100 X0101100X 101111X. 'o'
00100000 X0100000X X0101100 ','
01010111 X1010111X X.....X0 ' ' ','
01101111 X1101111X 100000XX 'W' ' '
01110010 X1110010X 1010111X 'W'
01101100 X1101100X X1101111 'o'
01100100 X1100100X X.X11100 'r' 'o'
00100001 X0100001X 10XX1101 'l' 'r'
100X..X1 'd' 'l'
100100X. 'd'
X0100001 '!'
X....... '!'
```
The `*` marks the Most Significant Bit in the output. Each bit in this column is either `1` or `X`. Removing any number of `.`s would cause either a `0` or `.` in the MSB column. If the input was `Hello, W` the last byte output would be `........`.
As usual, lowest score wins!
[Answer]
# Python 3, ~~144~~ ~~140~~ ~~131~~ ~~130~~ 137 bytes
*Damn bugs :(*
```
O=""
for Q in input():
C="X%07dX"%int(bin(ord(Q))[2:])
while"1">C[8-len(O)%8]:C="."+C
O+=C
O+="."
while O:print((O+"."*8)[:8]);O=O[8:]
```
This is really straight forward.
### Ungolfed with explanation
```
# initialize output buffer
output = ""
# loop through input
for char in input():
# get charcode, binary, remove 0b, parse as int, format
code = "X%07dX" % int(bin(ord(char))[2:])
# pad code while the line starting character would be 0
while "1" > code[8 - len(output) % 8]:
code = "." + code
# append result to output buffer
output += code
# add dot to ensure padding in end
output += "."
# loop while any output is left
while output:
# print line of output, with padding
print((output + "." * 8)[:8])
# remove printed output
output = output[8:]
```
[Answer]
## JavaScript (ES6), 187 bytes
```
f=(s,t=[...s].map(c=>(c.charCodeAt()*2+257).toString(2).replace(/^1|1$/g,'X')).join``)=>t.match(r=/^(.{8})*?0/)?f(s,t.replace(r,s=>s.replace(/X[01]*?$/,".$&"))):t+'.'.repeat(8-t.length%8)
```
Works by recursively finding `0`s at illegal positions and inserting a `.` before the preceding `X`. Ungolfed:
```
function f(s) {
t = '';
for (i = 0; i < s.length; i++) {
c = s.charCodeAt(i);
c = c.toString(2);
c = '000000' + c;
c = 'X' + c.slice(-7) + 'X';
t += c;
}
while (m = t.match(/^(.{8})*?0/)) {
p = t.lastIndexOf('X', m[0].length);
t = t.slice(0, p) + '.' + t.slice(p);
// if one dot isn't enough, next loop will just add another
}
return t + '.'.repeat(8 - t.length % 8); // pad up to 8 characters
}
```
] |
[Question]
[
The city of Poughkeepsie celebrates Halloween every year. Geographically, the city is a rectangle that is 30 miles long and 45 miles wide. On a map, it looks like a grid, with its east-west roads horizontally dividing the city into 1-mile-long rectangles and its north-south roads vertically dividing the city likewise. There is one house at each road intersection.
The city's residents tend to be more generous with their candy as one moves toward the center of the rectangle. The resident at the lower-left corner of the city - whom we'll call Bob - gives out 10 candies per child. If a child starts at Bob's house and proceeds eastward, each resident they come across will give them 5 more candies than the last one (In other words, Bob's nearest eastern neighbor will give 15 candies. If a child walks another mile to the next eastern neighbor, they get another 20 candies.) After they reach the horizontal center street, that number decreases by 5. If that same child instead proceeds northward of Bob's house - which is located at (0,0) - each resident they meet will give them 10 more candies than the previous resident. After they reach the relevant center street, each resident they meet will give 10 less.
The number of candies given out by residents who do not live on the edges of the city is the sum of the number of candies given out by the two neighbors who live on the nearest borders of the city. So, a resident who lives at (44,29) will give out the number of candies given by the resident at (45,29) + the number of candies given by the resident at (30,44).
**Important note:** The only way to access each house is by walking along roads or adjacent paths. One is not allowed to, for example, bee-line from Bob's house to (1,1) - s/he must first either walk along the y-axis for 1 mile, turn right and walk for another mile; or walk along the x-axis for 1 mile, turn left and walk for another mile. Also, once a child has received candy from a house, they will receive no more candy from that same house.
**Objective:**
Your program is to figure out how much candy a child can receive if s/he starts at Bob's house and is to walk no more than a given distance "d".
**Scoring**
Programs will be scored based on the size (in bytes) of the source code.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 58 bytes
```
Ø+0r;U$ṗµØ1W;⁸+\Q%“.þ‘)ẎẠ$Ƈµ20Ḋש5Ḋ+þ14Ḋ×⁵¤⁺;"Wɼ;ŒBm0⁸œị§Ṁ
```
[Try it online!](https://tio.run/##y0rNyan8///wDG2DIutQlYc7px/aeniGYbj1o8Yd2jGBqo8a5ugd3veoYYbmw119D3ctUDnWfmirkcHDHV2Hpx9aaQqktQ/vMzQB8x81bj205FHjLmul8JN7rI9Ocso1AJpydPLD3d2Hlj/c2fD//38LAA "Jelly – Try It Online")
Very slow (brute force), TIO can handle up to `8`. Test cases in \$[0,8]\$: [Try it online!](https://tio.run/##AXoAhf9qZWxsef//w5grMHI7VSThuZfCtcOYMVc74oG4K1xRJeKAnC7DvuKAmCnhuo7huqAkxofCtTIw4biKw5fCqTXhuIorw74xNOG4isOX4oG1wqTigbo7IlfJvDvFkkJtMOKBuMWT4buLwqfhuYD/xbssw4ck4oKsR///OA "Jelly – Try It Online")
] |
[Question]
[
**This question already has answers here**:
[Tell me how many math problems I have to do!](/questions/51189/tell-me-how-many-math-problems-i-have-to-do)
(11 answers)
Closed 8 years ago.
# The Challenge
I always write my math assignments down in the same way. For example:
```
pg. 420: #25, 50-56, 90
pg. 26: #50-60 evens, 70-80 odds, 90-99 3s
pg. 69: #12, 16, 18, 37
```
But I need you to tell me the individual problem numbers. For example:
```
input:
pg. 420: #25, 50-56, 90
output:
25, 50, 51, 52, 53, 54, 55, 56, 90
```
Here are the rules for telling me my problem numbers:
The assignment always starts with `pg. (number): #`, feel free to discard it.
Each group of problems is separated by a comma, and different patterns mean different things.
A single number (`4, 6, 7438, 698236`) just means that one problem is in the assignment.
Two numbers with a dash between them means those two numbers and all integers between. For example, `1-6` would become `1, 2, 3, 4, 5, 6`
If two numbers have a dash between them, then there's a word, there is a special rule for the numbers.
If the word is `evens`, then all even numbers between the two are included (`1-6 evens -> 2, 4, 6`).
If the word is `odds`, then all odd numbers between the two are included (`1-6 odds -> 1, 3, 5`).
If the word is `3s`, then all numbers where `n mod 3 = 0` between the two are included (`1-6 3s -> 3, 6`);
## Test Examples: (inputs then outputs)
```
pg. 1: #1, 2, 3
1, 2, 3
pg. 82: #76, 84-87, 91, 94-100 evens, 103-112 3s
76, 84, 85, 86, 87, 91, 94, 96, 98, 100, 103, 106, 109, 112
pg. 9001: #9000-9002 odds
9001
```
This is code-golf, so your score is the number of bytes.
[Answer]
# JavaScript (ES7), 138 bytes
```
F=s=>s.replace(/.*#|(\d+)-?(\d+)? ?(\d|\w*)s?/g,(_,a,b,c)=>b?[for(i of Array(b-a--+1))if(++a*c?(b-a)%c<1:!c||a%2==c>'f')a].join`, `:a||'')
```
```
F=s=>s.replace(/.*#|(\d+)-?(\d+)? ?(\d|\w*)s?/g,(_,a,b,c)=>b?[for(i of Array(b-a--+1))if(++a*c?(b-a)%c<1:!c||a%2==c>'f')a].join`, `:a||'')
button.onclick=()=>output.innerHTML=F(range.value)
```
```
button, textarea {
display: block;
width: 100%;
margin-bottom: 0.5em;
box-sizing: border-box;
}
```
```
<textarea id="range"></textarea>
<button id="button">submit</button>
<div id="output"></div>
```
] |
[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/50276/edit).
Closed 6 years ago.
[Improve this question](/posts/50276/edit)
Once upon a time long long ago... when there was no money or stocks yet, people were trading sheep. Even before (but close to) the invention of abacus, the great-grandfather of Warren Buffet decided it was hard to keep track of sheep. He wanted to collect all his belongings and clear all his debt, so that he could invest in a new counting machine he heard that his friend, great-grandfather of Bill Gates was building from sticks and beads. All his trades were atomic i.e. he was either supposed to give exactly one sheep to someone or get exactly one sheep. Of course Grandpa Buffet has more sheep to get then to give. Actually he exactly had 749 sheep to collect and he owed 250 sheep, so he was up by 499 sheep. Because of that he built a barn exactly for 499 sheep beforehand. Then he called all 999 people and told them to get into a queue. The very first man, wanted his sheep but there was no sheep in the barn yet. He didn't like this order and wanted everyone to get in order again but first the givers and then the collectors now. At the 500th men there were no space for new sheep in the barn but there were still 250 to collect before starting to give. He gave all the collected sheep back and make them get in a queue again and went to Grandpa Gates to help him ordering. Somehow they figured out and with the help of 499 sheep, they built a lot of Abacus and lived happily ever after.
Years later, yesterday Bill Gates and Warren Buffet met in a Giving Pledge meeting. They told this story and laughed a lot. Then Gates told Buffet: "You know what, I don't know how my great-grandpa ordered 999 people but I know there are so many ways. Actually I can tell you how many if you let me...". Then he went to his room to write a code to calculate the number of possible orderings that always guarantee there is always sheep or space in the barn until the queue is empty. And he did so but being Bill Gates he has written a recursive function which solves the problem correctly but slowly. So everybody still waits for his answer. Buffet is bored, can you write a better and faster function?
```
p = 749
n = 250
orderings(p,n) = ?
```
Shortest code wins, but it must finish in minutes, not hours or days.
[Answer]
# Pyth, 33 bytes
```
M?+&<HGgtGH&+-499GHgGtHH1g749 250
```
Try it online: [Pyth Compiler/Executor](https://pyth.herokuapp.com/?code=M%3F%2B%26%3CHGgtGH%26%2B-499GHgGtHH1g749%20250&debug=0). Takes about 3 seconds on my laptop. The online compiler is a bit slower, but also computes the answer in about 15 seconds.
The answer is:
```
160547283350099323317963999889002394629262478407796913030854915361460989263675794524349914992326520887556329626280682363011590724268659750627030457440692447081328860242720905181098211539560301455338502543318855115593179999323115473879753632000
```
### Explanation:
First some pseudo-code of the recursive function. This is quite easy to write.
```
function g(p, n):
if (p > 0 and n > 0):
count = 0
if (occupied_places_in_barn < 499):
count += g(p-1, n)
if (occupied_places_in_barn > 0):
count += g(p, n-1)
return count
else:
return 1 # only one way possible
```
And the Pyth translation:
```
M def g(G,H): return _
<HG H < G
& gtGH and g(G-1,H)
+-499GH 499-G+H
& gGtH and g(G,H-1)
+ return sum of these two numbers
? H1 if H else 1
g749 250 call g(749,250) and print
```
**Why is this recursive code so fast?** Doesn't the function `g` iterate over all 1.6\*10^199 possibilities?
No it doesn't. The key here is dynamic programming. We store known results in a cache and lookup the results, when we call the function with the same parameters again. One really cool feature of Python is the `@lru_cache` decorator, which does all the work for you. No need to manually generate such a cache and handle stuff like lookup, storing results, ... And in Pyth it's even simpler, since each function automatically uses such a cache. So in total the function `g` gets executed only 125499 times. Way less than 1.6\*10^199 times.
] |
[Question]
[
I'd like to get a list of words that are strongly connected with a particular time epoch, for example, 19th century, 20th century and 21st century. I suspect that nobody used a word like "smartphone" in 19th and 20th century, and, vice versa, nobody still uses a word like "grubble" anymore in 21th century.
# Input data
I have quite a few books, laid out in a following directory structure:
* On the first level, you have directories named after years when book was published, i.e. from `1801` to `2015`.
* On the following levels, there could be individual book files or any number of nested directories (for example, grouping books by authors, by genres, by publishers, etc). Ultimately, there's at least a single book inside every such directory. Let's say that names of these files and directories are limited by whatever's allowed on [VFAT filesystem](https://en.wikipedia.org/wiki/Long_filename) (i.e. `\` `/` `:` `*` `?` `"` `<` `>` `|` are not allowed).
No other files exist in this structure (for example, a program file would be located elsewhere, no results of previous runs, temporary files, etc).
All book files have the same pure text format, using only ASCII character set. Words are continuous non-empty character sequences of word characters, i.e. `[A-Za-z0-9_]+`.
>
> For example, contents of this short book:
>
>
> `Here you go, that's APL13-X for your 4923/YR_3.`
>
>
> have the following words: `Here`, `you`, `go`, `that`, `s`, `APL13`, `X`, `for`, `your`, `4923`, `YR_3`.
>
>
>
Comparison of words is *case insensitive*, that is `Here`, `here` and `HERE` is the same word.
# The task
I want to have a program that, being started in a top directory of this structure, would generate 3 files named `19`, `20`, `21`. Each of these files should contain a list of words which occur only in relevant century books and not in any other century's single book (words separated with a newline). Words can be in any case, but all words given in such file must appear only once.
# Sample test cases
If you want a sample test case, feel free to use my one, available either as [zip file](https://github.com/GreyCat/sample-books-word-stats/archive/35c74d2c41abc92a1b3c48298170393b0363cb84.zip) or [git repo](https://github.com/GreyCat/sample-books-word-stats).
# Scoring
Standard code golf rules apply. Shortest answer (written in a language released before 2015-03-16) wins after 3 weeks would pass (on 2015-04-06). Secondary nominations are "shortest answer in any non-esoteric, general purpose language" and "shortest answer per language".
**P.S.** Please note that "19th century" is [defined as 1801..1900 inclusive](https://en.wikipedia.org/wiki/19th_century), that is `1900` is still 19th.
[Answer]
# R, ~~284~~ 266
Reads in every file from the specified working directory and uniquely adds their words to the appropriate century word vector. Each word vector is compared to the others and the words that are not in are written out.
```
C=as.character;S=strsplit;L=tolower;U=unlist;W=list();for(f in list.files(r=T)){Y=C((strtoi(U(S(f,'/'))[1])-1)%/%100+1);W[[Y]]=unique(L(c(W[[Y]],U(S(scan(f,w=C()),'[^A-Za-z0-9_]',p=T)))))};for(i in 1:3)cat(W[[i]][!L(W[[i]])%in%L(U(W[-i]))],file=names(W)[i],sep='\n')
```
**Caveats:**
* Assumes the current directory is pointing in the right place. Otherwise use `setwd()`
* There must be at least one file per century and no additional files outside the 19th, 20th and 21st centuries.
In a more readable form
```
setwd("some/directory/here");
# Commonly used functions
C=as.character;
S=strsplit;
L=tolower;
U=unlist;
# Initialise word list
W=list();
# for each file in working directory
for(f in list.files(r=T)){
# Determine century from first part of path.
Y=C((strtoi(U(S(f,'/'))[1])-1)%/%100+1);
# Scan the file splitting on non letters/numbers/underscore
# refreshing the unique list of words for the century
W[[Y]]=unique(L(c(W[[Y]],U(S(scan(f,w=C()),'[^A-Za-z0-9_]',p=T)))))
};
# Write out the words for each century that aren't in the other centuries
for(i in 1:length(W))
cat(W[[i]][!L(W[[i]])%in%L(U(W[-i]))],file=names(W)[i],sep='\n')
```
[Answer]
# Shell script (reference solution, 879 bytes)
```
#!/bin/sh
# This program uses temporary files, but no need to perform any kind
# of cleanup in a real answer.
# Given a stream of lines on the stdin, rejects all lines that match
# lines in a file given in first argument. Both stdin stream and a
# given file must be sorted the same way.
reject()
{
diff -u - "$1" | grep '^-' | cut -c2- | sed 1d
}
# Collect lists of words
for YEAR in ????; do
CENTURY=$((($YEAR - 1) / 100 + 1))
find "$YEAR" -type f -print0 |
xargs -0 sed 's/\(.*\)/\L\1/g; s/[^A-Za-z0-9_]/\n/g;' >>words_$CENTURY
done
# Make lists unique and sorted
for C in 19 20 21; do
sort -u <words_$C >words_unique_$C
done
# Output results
cat words_unique_19 | reject words_unique_20 | reject words_unique_21 >19
cat words_unique_20 | reject words_unique_19 | reject words_unique_21 >20
cat words_unique_21 | reject words_unique_19 | reject words_unique_20 >21
```
[Answer]
# Shell script, 233 bytes
```
J(){
diff -u - $1|grep ^-|cut -c2-|sed 1d
}
for Y in *; do
C=$(((Y-1)/100-18))
find $Y -type f -exec sed 's/\(.*\)/\L\1/;s/[^A-Za-z0-9_]/\n/g' {} +>>W$C
done
S(){
sort -u
}
S<W0>A
S<W1>B
S<W2>C
J B<A|J C>19
J A<B|J C>20
J A<C|J B>21
```
Basically a very compressed version of reference solution. Everything that could be replaced with 1-letter name was replaced. Still works in minimal sh.
[Answer]
# Ruby, 231 bytes
```
require'set'
m=[]
Dir['**/*'].map{|n|(m[(n[0..3].to_i-1)/100-18]||=Set.new).merge(IO.read(n).split(/\W/).map{|x|x.upcase})rescue''}
u=[m[0]-m[1]-m[2],m[1]-m[0]-m[2],m[2]-m[0]-m[1]]
3.times{|i|IO.write"#{i+19}",u[i].to_a.join("\n")}
```
In slighty more readable form with comments, with lvalues extracted:
```
require'set'
m = []
Dir['**/*'].map { |n|
# Determine century from first 4 characters of path
c = (n[0..3].to_i - 1) / 100
# Make array indices 1 char long (0-1-2) instead of 2 chars (19-20-21)
c -= 18
# Initialize per-century array entry with empty set, if required
m[c] ||= Set.new
# Read file as a string, split by words, uppercase everything
# (not lowercase, because "upcase" saves 2 bytes vs "downcase"),
# merge into the set we've prepared; ignore any possible exceptions
# (i.e. trying to read the directory as a string)
m[c].merge(IO.read(n).split(/\W/).map { |x| x.upcase }) rescue ''
}
# New array of sets with unique words per century
u = [
m[0] - m[1] - m[2],
m[1] - m[0] - m[2],
m[2] - m[0] - m[1]
]
# Output of this array entries, each to individual file
3.times { |i|
IO.write "#{i + 19}", u[i].to_a.join("\n")
}
```
] |
[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 7 years ago.
[Improve this question](/posts/36212/edit)
**Objective:** Print all multiples of 32 from 0 to an arbitrary number n.
**Rules:**
1. One argument will be given: a single integer from 0 to 231 - 1. This will be `n` here on out.
2. The first iteration must be 0, and the last iteration must be `n`. 0 is to be counted as a multiple of 32.
3. Each time a multiple is encountered, the multiple itself must be printed with no leading whitespace, and then it must be immediately followed by a newline (CR, CRLF, and LF are all acceptable as long as they are consistent.
4. A bug must be introduced such that a minimum of `n+1 floor 32` cases are incorrectly printed/omitted (in the average case).
* Perfection is allowed for `n` less than or equal to 32.
5. Your source code must be in pure ASCII. Exceptions only include APL and others that use non-ASCII operators.
6. This is an [underhanded](/questions/tagged/underhanded "show questions tagged 'underhanded'") contest. The best code is clear, concise, obvious, and wrong.
**Example in C++ (except for clear bug):**
```
// This conforms to the rules, but is a bad entry.
#include <iostream>
#include <cstdlib>
#include <cstdint>
int main(int argc, char* argv[]) {
int32_t max = (int32_t) atol(argv[1]);
int32_t i = 0;
while (i != max) {
if (!(i % 32) && !((int) (4 * random()) / 4)) {
cout << i << endl;
}
i++;
}
return 0;
}
```
Most popular answer wins, so make it good!
[Answer]
## C
```
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[]) {
int n = atoi(argv[1]);
for(int i = 0; i < n; i++) {
if(i & 31 == 0) {
printf("%d\n", i);
}
}
}
```
[Answer]
modified from the example.
```
#include <iostream>
#include <cstdlib>
#include <cstdint>
using namespace std;
int main(int argc, char* argv[]) {
int32_t n = (int32_t) atol(argv[1]);
int32_t i = 0;
while (i != n) {
if (!(i % 32) && n > 32 ? rand() % 4 != 0 : 1) {
cout << i << endl;
}
++i;
}
return 0;
}
```
Issues:
```
rule 1: 1 argument. check.
rule 2: first iteration must be 0.
check.
last iteration must be n.
fail. "while (i != n)" means the last iteration is n - 1.
rule 3: print multiples of 32.
check, except for the bug below
rule 4: print "n+1 floor 32" entries incorrectly.
not sure what this means, but I certainly don't meet it. I chose to have each multiple of 32 have a 1 in 4 chance of being incorrectly omitted.
rule 5: allowable characters
I didn't actually check, but I didn't intentionally break this rule.
rule #6: there is no rule #6
rule 6: underhanded
the program actually prints all numbers from 1 to n - 1, except a random number of multiples of 32.
the bug is in the operator precedence of the conditional operator:
if (!(i % 32) && n > 32 ? ((rand() % 4) != 0) : 1) {
the condition says "if i is a multiple of 32 AND n is greater than 32, (return true if a random number is a multiple of 4. return false if it is not). Otherwise, return true.
all multiples of 32 have a 1 in 4 chanse of being omitted.
all other numbers are always printed.
the line should be:
if (!(i % 32) && (n > 32 ? rand() % 4 != 0 : 1)) {
```
] |
[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/21892/edit).
Closed 9 years ago.
[Improve this question](/posts/21892/edit)
The idea here is to write a little segment that will spit out regular expression patterns when given a string that matches them.
As you might have guessed, this will be a popularity contest, and I'll accept whichever answer has the most upvotes by March 7th
pseudocode Example:
```
print(reverseRegex('dog'));
//prints /[a-z]{3}/, /dog/, and a bunch other stuff
```
EDIT: The regular expressions spat out should not exceed 3 times the input string's length
[Answer]
# Ruby
```
def esc chr
'\\[]'.index(chr) ? "\\#{chr}" : chr
end
def reverse_regex str
ords = str.chars.to_a.uniq.map(&:ord).sort
prev = ords.first
ranges = ords.slice_before{|x|
prev, prev2 = x, prev
prev2 + 1 != x
}.map{|x| x[0]..x[-1]}
reversed = "[#{ranges.map{|c|esc(c.min.chr) + (c.min == c.max ? '' : (c.min + 1 == c.max ? '' : '-') + esc(c.max.chr))}*''}]{#{str.size}}"
reversed.size > str.size * 3 ? /#{Regexp.escape str}/ : /#{reversed}/
end
```
Sample outputs:
```
reverse_regex 'dogs are delicious'
=> /[ ac-egilorsu]{18}/
reverse_regex 'a'
=> /a/
reverse_regex ''
=> //
reverse_regex 'This is a test: []{}.*potato'
=> /[ *.:T\[\]aehiopst{}]{28}/
```
Now with ranges!
These regexen match the entire string (if you added `^...$` it would still match, but I'm too lazy to do that and add the required length check). Also, I'm assuming the `/`s don't count for length. (If they did, it would be impossible for input of empty string.)
[Answer]
# Python 3.2
If you wish for soemthing very short, as usual you can use `python`.
It is well known that you can do anything in `python` with few `import`s. In this case, this task is such simple that in `python 3.2` you don't even need an `include`.
```
def reverse_regex(string):
return '/.*/'
print (reverse_regex('dog'))
print (reverse_regex('I can haz a cheezburger.'))
print (reverse_regex('123-ABC-abc'))
```
You will see all these expression are valid.
UPDATE:
This new code (although a bit more long) is able to show multiple regex for eacah word.
```
def reverse_regex(string):
print ('/.*/')
print ('/'+string+'/')
reverse_regex('dog')
reverse_regex('I can haz a cheezburger.')
reverse_regex('123-ABC-abc')
```
] |
[Question]
[
Given the scheme of the fleet of the human player, let the user choose which coordinates attack each turn.
The "computer player" will then attack on its turn following the classic rules of battleship. (The computer player must be able to win, you can't make the computer attack every turn the same cell)
The schemes must contain all the needed ships, this is the list:
```
[ ][ ] x 4
[ ][ ][ ] x 3
[ ][ ][ ][ ] x 2
[ ][ ][ ][ ][ ][ ] x 1
```
The scheme must follow the example below, and must be one for each player.
```
[ ][ ] [ ] [ ][ ][ ][ ]
[ ]
[ ] [ ] [ ][ ][ ] [ ]
[ ] [ ]
[ ]
[ ] [ ] [ ]
[ ] [ ]
[ ][ ] [ ]
[ ][ ][ ][ ][ ][ ]
```
To input the player scheme you can just hard-code it in your script or let the user insert it in some way (use a specific char to separate rows or let user inser one row per time etc, up to you), the important thing is that your player must be able to easily insert a new scheme (no minified/compressed input so).
The fleet owned by the computer must be randomly generated by the script.
The coordinates are a number(1-10) and a letter(A-L), this is an example battlefield with coordinates:
```
A B C D E F G H I L
|‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
1 | [ ][ ] [ ] [ ][ ][ ][ ]
2 | [ ]
3 | [ ] [ ] [ ][ ][ ] [ ]
4 | [ ] [ ]
5 | [ ]
6 | [ ] [ ] [ ]
7 | [ ] [ ]
8 | [ ][ ] [ ]
9 |
10 | [ ][ ][ ][ ][ ][ ]
```
Each turn the script must ask which coordinates hit, and return an indication:
* **not hit** = the selected coordinates doesn't match a part of a ship
* **hit** = the selected coordinates does match part of a ship but the ship is not yet sunk
* **hit and sunk** = the selected coordinates does match part of a ship and the ship is sunk
Then it will have to make the computer hit a cell (bonus points if you can write a smart script that will be challenging) and indicate to user which cell was hit and if one of his ships was hit (same indications of above).
Example "gameplay" log:
```
Your coordinates: A1
hit
Enemy coordinates: C1
not hit
Your coordinates: B1
hit and sunk
```
if the user chooses two times the same coordinates consider it as **not hit** or just ignore it
The expected **final** outputs (when one of the two players has not ships available) are the two schemes with the coordinates hit by the computer player marked with an `x`, example of the first scheme:
```
[x][x] [x] [x][x][x][ ]
x [x]
[ ] x [x] [ ][ ][x] [x]
[ ] [x]
[ ] x
[x] [x] [ ]
[x] x [ ]
[ ][ ] x [ ]
x [ ][ ][x][ ][ ][ ]
```
It's probably not the easiest code-golf challenge here but as usual, the shortest code will win.
[Answer]
Well, better late than never. I remembered doing something like this in a school class long time ago... Ungolfed and waaaaaay too long.
```
#include <iostream>
#include <ctime>
#include <sstream>
#include <cstdlib>
using namespace std;
class board{
private:
char grid[10][10];
public:
void initializeGrid(){
for (int row=0; row<10; row++){
for (int column=0; column<10; column++){
grid[row][column]='~';
}
}
}
void displayGrid(bool hideShips=false){
int y=10;
for (int i=0; i<10; i++){
if (y!=10){cout<< " ";}
cout<<y;
for (int c=0; c<10; c++){
cout<<" ";
if (grid[i][c]=='X'){
if (hideShips==true){
cout<<"~";
}else{
cout<<grid[i][c];
}
}else{cout<<grid[i][c];}
}
y--;
cout<<endl;
}
cout<<" A B C D E F G H I J"<<endl;
}
char getSpace(int x, int y){
return grid[y][x];
}
void addSpace(char space, int x, int y){
grid[y][x]=space;
}
};
class ship{
private:
int length;
board* boardOP;
public:
ship(int L, board* BOP){
length=L;
boardOP=BOP;
}
bool buildShip(int *X, int *Y, int dX, int dY, board *boardOP){
int shipStore[10]={-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
for(int i=0; i<length; i++){
shipStore[i*2]=*X;
shipStore[i*2+1]=*Y;
if (*Y+dY<10&&*Y+dY>-1
&&*X+dX<10&&*X+dX>-1
&&boardOP->getSpace(*X+dX,*Y+dY)=='~'){
*Y=*Y+dY;
*X=*X+dX;
}else{return false;}
}
for(int c=0; c/2<length; c+=2){
boardOP->addSpace('X',shipStore[c],shipStore[c+1]);
}
return true;
}
int getLength(){return length;}
};
class player{
protected:
board* thisBoardOP;
board* otherBoardOP;
int X;
int Y;
int hits;
public:
virtual void go(){}
player(){
hits=0;
}
bool won(){
if(hits==17){return true;
}else{return false;}
}
bool hit(){
if (otherBoardOP->getSpace(X-1,10-Y)=='X'){
cout<<"hit!"<<endl;
hits++;
otherBoardOP->addSpace('#',X-1,10-Y);
return true;
}else{
cout<<"miss!"<<endl;
otherBoardOP->addSpace('O',X-1,10-Y);
return false;
}
}
void arrangeShips(){
ship aircraftCarrier(5,thisBoardOP);
positionShip(&aircraftCarrier);
ship battleship(4,thisBoardOP);
positionShip(&battleship);
ship cruiser(3,thisBoardOP);
positionShip(&cruiser);
ship destroyer(3,thisBoardOP);
positionShip(&destroyer);
ship patrolBoat(2,thisBoardOP);
positionShip(&patrolBoat);
}
void positionShip(ship* type){
while(1){
int dY=0;
int dX=0;
dX=(rand()%2)-(rand()%2);
if(dX==0){
dY=(rand()%2);
if(dY==0){(dY)--;}
}else{dY=0;}
int Y=(rand()%10);
int X=(rand()%10);
if (thisBoardOP->getSpace(X,Y)=='~'){
if (type->buildShip(&X,&Y,dX, dY,thisBoardOP)==false){
dX*=-1;
dY*=-1;
if (type->buildShip(&X,&Y,dX,dY,thisBoardOP)==true){return;}
}else{return;}
}
}
}
};
class human: public player{
public:
human(board* tBOP, board* oBOP){
thisBoardOP=tBOP;
otherBoardOP=oBOP;
}
void go(){
setXY();
hit();
cout<<X<<endl;
cout<<Y<<endl;
}
void setXY(){
string input;
while(1){
do{
cout<<endl<<"Enter x coordinate:"<<endl;
char letterX='\0';
cin>>input;
if (input.length()==1){letterX=input[0];}
X=convertLetter(letterX);
if(X==0){cout<<endl<<"Please enter a valid letter between A-J"<<endl;}
}while(X==0);
do{
cout<< endl<<"Enter y coordinate:"<<endl;
cin>>input;
stringstream(input)>>Y;
if(Y>10||Y<1){cout<<"Please enter a valid number between 1-10"<<endl;}
}while(Y>10||Y<1);
if(otherBoardOP->getSpace(X-1,10-Y)=='#'
||otherBoardOP->getSpace(X-1,10-Y)=='O'){
cout<<endl<<"You cannot shoot a space that has already been hit!"<<endl;
}else{break;}
}
}
int convertLetter(char letter){
if (int(letter)>64&&int(letter)<75){
return int(letter)-64;
}else if(int(letter)>96&&int(letter)<107){
return int(letter)-96;
}
return 0;
}
};
class computer: public player{
private:
int originX;
int originY;
int vX;
int vY;
bool foundEnd1;
bool foundEnd2;
bool foundDirection;
bool oppositeCheck;
int distance;
int count;
public:
computer(board* tBOP, board* oBOP){
thisBoardOP=tBOP;
otherBoardOP=oBOP;
originX=0;
originY=0;
vX=0;
vY=0;
foundEnd1=false;
foundEnd2=false;
foundDirection=false;
oppositeCheck=false;
distance=2;
count=0;
}
void go(){
setXY();
if(hit()==true){
if(originX==0){
originX=X;
originY=Y;
}else if(foundDirection==false){
foundDirection=true;
if(oppositeCheck==true){
if(vX<0||vY<0){foundEnd1=true;
}else{foundEnd2=true;}
}
}
}else if(foundDirection==true){
if (X-originX>0||Y-originY>0){foundEnd1=true;
}else{foundEnd2=true;}
}
}
void setXY(){
if(originX!=0){
if(foundEnd1==false
||foundEnd2==false){
if(foundDirection==false){
findDirection();
}else{
findRest();
}
}
if(foundEnd1==true
&&foundEnd2==true){
originX=0;
originY=0;
vX=0;
vY=0;
foundEnd1=false;
foundEnd2=false;
foundDirection=false;
oppositeCheck=false;
distance=2;
count=0;
}
}
if (originX==0){
do{
X=(rand()%10)+1;
Y=(rand()%10)+1;
}while(otherBoardOP->getSpace(X-1,10-Y)=='O'
||otherBoardOP->getSpace(X-1,10-Y)=='#');
}
}
void findDirection(){
if(count==0){
vX=(rand()%2)-(rand()%2);
if(vX==0){
vY=(rand()%2);
if(vY==0){(vY)--;}
}else{vY=0;}
}
while(count<4){
if(count==2){oppositeCheck=false; int i=vX; vX=vY; vY=i;
}else if(count!=0){oppositeCheck=true; vX*=-1; vY*=-1;}
count++;
if(originX+vX<11&&originX+vX>0
&&originY+vY<11&&originY+vY>0
&&otherBoardOP->getSpace((originX+vX)-1,10-(originY+vY))!='#'
&&otherBoardOP->getSpace((originX+vX)-1,10-(originY+vY))!='O'){
X=originX+vX;
Y=originY+vY;
return;
}
}
foundEnd1=true;
foundEnd2=true;
}
void findRest(){
int adjustment=0;
if(foundEnd1==true){
if(vX<0||vY<0){adjustment=1;
}else{adjustment=-distance;}
}else if(foundEnd2==true){
if(vX<0||vY<0){adjustment=-distance;
}else{adjustment=1;}
}else{
adjustment=(rand()%2);
if(adjustment==0){adjustment=-distance;}
}
if (vX<0||vY<0){adjustment*=-1;}
int i=0;
while(i<2&&(foundEnd1==false||foundEnd2==false)){
if (vX==0){
if(originY+vY+adjustment>0
&&originY+vY+adjustment<11
&&otherBoardOP->getSpace(originX-1,10-(originY+vY+adjustment))!='#'
&&otherBoardOP->getSpace(originX-1,10-(originY+vY+adjustment))!='O'){
Y=originY+vY+adjustment;
if(adjustment==1||adjustment==-1){vY+=adjustment;}
distance++;
return;
}
}else{
if(originX+vX+adjustment>0
&&originX+vX+adjustment<11
&&otherBoardOP->getSpace((originX+vX+adjustment)-1,10-originY)!='#'
&&otherBoardOP->getSpace((originX+vX+adjustment)-1,10-originY)!='O'){
X=originX+vX+adjustment;
if(adjustment==1||adjustment==-1){vX+=adjustment;}
distance++;
return;
}
}
if(adjustment==1){adjustment=-distance; foundEnd1=true;
}else if(adjustment==-1){adjustment=distance; foundEnd2=true;
}else if(adjustment==distance){adjustment=-1; foundEnd1=true;
}else{adjustment=1; foundEnd2=true;}
i++;
}
}
};
int main(){
srand((unsigned int)(time(0)));
board boardO1;
boardO1.initializeGrid();
board boardO2;
boardO2.initializeGrid();
human humanO(&boardO2,&boardO1);
humanO.arrangeShips();
computer computerO(&boardO1,&boardO2);
computerO.arrangeShips();
player* playerOP=&humanO;
while(1){
boardO1.displayGrid(true);
cout<<endl;
boardO2.displayGrid();
playerOP->go();
if(playerOP->won()==true){
cout<<endl;
if(playerOP==&humanO){
cout<<"You win!"<<endl;
}else{
cout<<"Computer wins!"<<endl;
}
cout<<endl;
boardO1.displayGrid(true);
cout<<endl;
boardO2.displayGrid();
break;
}
if (playerOP==&humanO){playerOP=&computerO;
}else{playerOP=&humanO;}
}
return 0;
}
```
**Result:**
```
./a.out
10 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
9 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
8 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
7 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
6 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
5 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
4 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
3 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
2 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
1 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
A B C D E F G H I J
10 ~ ~ ~ ~ ~ ~ ~ ~ X ~
9 ~ ~ ~ X ~ ~ ~ ~ X ~
8 X ~ ~ X ~ ~ ~ ~ X ~
7 X ~ ~ X ~ ~ ~ ~ X ~
6 X ~ ~ ~ ~ X X X X ~
5 X ~ ~ ~ ~ ~ ~ ~ ~ ~
4 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
3 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
2 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
1 ~ ~ ~ ~ ~ ~ ~ ~ X X
A B C D E F G H I J
Enter x coordinate:
d
Enter y coordinate:
4
hit!
4
4
10 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
9 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
8 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
7 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
6 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
5 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
4 ~ ~ ~ # ~ ~ ~ ~ ~ ~
3 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
2 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
1 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
A B C D E F G H I J
10 ~ ~ ~ ~ ~ ~ ~ ~ X ~
9 ~ ~ ~ X ~ ~ ~ ~ X ~
8 X ~ ~ X ~ ~ ~ ~ X ~
7 X ~ ~ X ~ ~ ~ ~ X ~
6 X ~ ~ ~ ~ X X X X ~
5 X ~ ~ ~ ~ ~ ~ ~ ~ ~
4 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
3 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
2 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
1 ~ ~ ~ ~ ~ ~ ~ ~ X X
A B C D E F G H I J
miss!
10 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
9 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
8 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
7 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
6 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
5 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
4 ~ ~ ~ # ~ ~ ~ ~ ~ ~
3 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
2 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
1 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
A B C D E F G H I J
10 ~ ~ ~ ~ ~ ~ ~ ~ X ~
9 ~ ~ ~ X ~ ~ ~ ~ X ~
8 X ~ ~ X ~ ~ ~ ~ X ~
7 X ~ ~ X ~ ~ ~ ~ X ~
6 X ~ ~ ~ ~ X X X X ~
5 X ~ ~ ~ ~ ~ ~ ~ ~ ~
4 ~ ~ ~ O ~ ~ ~ ~ ~ ~
3 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
2 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
1 ~ ~ ~ ~ ~ ~ ~ ~ X X
A B C D E F G H I J
Enter x coordinate:
d
Enter y coordinate:
7
miss!
4
7
10 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
9 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
8 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
7 ~ ~ ~ O ~ ~ ~ ~ ~ ~
6 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
5 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
4 ~ ~ ~ # ~ ~ ~ ~ ~ ~
3 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
2 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
1 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
A B C D E F G H I J
10 ~ ~ ~ ~ ~ ~ ~ ~ X ~
9 ~ ~ ~ X ~ ~ ~ ~ X ~
8 X ~ ~ X ~ ~ ~ ~ X ~
7 X ~ ~ X ~ ~ ~ ~ X ~
6 X ~ ~ ~ ~ X X X X ~
5 X ~ ~ ~ ~ ~ ~ ~ ~ ~
4 ~ ~ ~ O ~ ~ ~ ~ ~ ~
3 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
2 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
1 ~ ~ ~ ~ ~ ~ ~ ~ X X
A B C D E F G H I J
miss!
10 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
9 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
8 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
7 ~ ~ ~ O ~ ~ ~ ~ ~ ~
6 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
5 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
4 ~ ~ ~ # ~ ~ ~ ~ ~ ~
3 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
2 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
1 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
A B C D E F G H I J
10 ~ ~ ~ ~ ~ ~ ~ ~ X ~
9 ~ ~ ~ X ~ ~ ~ ~ X ~
8 X ~ ~ X ~ ~ ~ ~ X ~
7 X ~ ~ X ~ ~ ~ ~ X ~
6 X ~ ~ ~ ~ X X X X ~
5 X ~ ~ ~ ~ ~ ~ ~ ~ ~
4 O ~ ~ O ~ ~ ~ ~ ~ ~
3 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
2 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
1 ~ ~ ~ ~ ~ ~ ~ ~ X X
A B C D E F G H I J
Enter x coordinate:
d
Enter y coordinate:
4
You cannot shoot a space that has already been hit!
```
[Answer]
Since this is a rather involved problem, I'll be going at it step by step and posting here.
First part, computer board generation:
I used a very simple (yet rules-abiding) algorithm to determine where to put the boats.
```
from random import randint as t
r=range
a=10
d=(0,9)
s=[0]*a
c = [['' for _ in r(a)] for _ in r(a)]
for _ in "1234":
k=t(0,6)
c[k][s[k]],c[k][s[k]+1]=['d'+_]*2
s[k]+=2
for _ in "123":
k=t(0,6)
while(s[k]>7):
k=t(*d)
c[k][s[k]],c[k][s[k]+1],c[k][s[k]+2]=['s'+_]*3
s[k]+=3
for _ in "12":
k=t(0,8)
while(s[k]>6):
k=t(*d)
for q in r(4):
c[k][s[k]+q]='r'+str(_)
s[k]+=4
for _ in r(0,6):
c[9][s[9]+_]='b1'
s[9]+=6
#Testing
for line in c:
print(line)
```
A pretty standard output for the algorithm is:
```
['', '', '', '', '', '', '', '', '', '']
['d1', 'd1', 's1', 's1', 's1', 'r1', 'r1', 'r1', 'r1', '']
['d2', 'd2', 'd3', 'd3', '', '', '', '', '', '']
['s3', 's3', 's3', 'r2', 'r2', 'r2', 'r2', '', '', '']
['s2', 's2', 's2', '', '', '', '', '', '', '']
['d4', 'd4', '', '', '', '', '', '', '', '']
['', '', '', '', '', '', '', '', '', '']
['', '', '', '', '', '', '', '', '', '']
['', '', '', '', '', '', '', '', '', '']
['b1', 'b1', 'b1', 'b1', 'b1', 'b1', '', '', '', '']
```
] |
[Question]
[
**Task:**
Find the count of numbers between `A` and `B` (inclusive) that have sum of digits equal to `S`.
Also print the smallest such number between `A` and `B` (inclusive).
**Input:**
Single line consisting of `A`, `B`, and `S`.
**Output:**
Two lines.
In first line, the number of integers between A and B having sum of digits equal to S.
In second line, the smallest such number between A and B.
**Constraints:**
```
1 <= A <= B < 10^15
1 <= S <= 135
```
[Answer]
# Python, 105
```
a,b,s=input()
l=filter(lambda n:sum(int(s)for s in list(str(n)))==s,range(a,b+1))
print l[0]
print len(l)
```
[Answer]
# GolfScript, 35 bytes
```
~:S;),>{.10base{+}*S=!{;}*}%(\,)]n*
```
### How it works
```
~ # Interpret the input string.
:S; # Save the last integer in variable “S” and pop it from the stack.
), # Increment it by 1 and create the array “[0 ... B]”
> # Remove the first “A” elements. This leaves the array “[A ... B]”
{ # For each of those integers:
.10base # Push its digits in base 10.
{+}* # Add the digits.
S=!{;}* # If the sum is not equal to “S”, pop the integer from the stack.
}% # Collect the results into an array.
(\ # Extract the first and swap it below the array.
,) # Count the elements of the array of all remaining integers and increment by one.
n\ # Separate the results by a newline.
```
[Answer]
**Ruby, 109**
Golfed:
```
a,b,s=gets.split(',').map(&:to_i);m=(a..b).select{|n|n.to_s.chars.map(&:to_i).reduce(:+)==s};puts m.size,m[0]
```
Ungolfed:
```
min, max, target_sum = gets.split(',').map(&:to_i)
matches = (min..max).select do |n|
sum = n.to_s.chars.map(&:to_i).reduce(:+)
sum == target_sum
end
puts matches.size
puts matches.first
```
[Answer]
## [GTB](http://timtechsoftware.com/?page_id=1309 "GTB"), 32
```
`A,B,Sn?A,B)‚ÜíL1:SortA(L1~L1=S~L1
```
] |
[Question]
[
The clustering coefficient of a graph (or network) is a:
>
> measure of degree to which nodes in a graph tend to cluster together
>
>
>
[The Wikipedia article](http://en.wikipedia.org/wiki/Clustering_coefficient#Network_average_clustering_coefficient) gives a much better description of how network average clustering coefficient is calculated from local clustering coefficients than I could give.
## The Challenge
Given an adjacency matrix `a` describing an undirected network (or graph) with no self loops, calculate it's network average clustering coefficient.
### Details
* You must write a program/function/procedure/code block which calculates the network average clustering coefficient for any undirected graph with no self loops.
* The output may only contain the coefficient and nothing else.
* You are to assume that your program (or whatever) has access to an adjacency matrix describing the graph through a variable/the stack/file/whatever
* You may not use any inbuilt functionality your language may have to calculate clustering coefficients
* **Shortest code wins**
### Test Examples
Test inputs and outputs can be found in [this pastebin](http://pastebin.com/X2zqkwyE)
### My solution: [GNU Octave](http://www.gnu.org/software/octave/), 93 chars
(behind spoiler)
>
>
> ```
> f=sum(a);c=0;for i=find(f>1)c+=sum(a(t=find(a(i,:)),t)(:))/(f(i)*(f(i)-1));endfor;c/length(a)
> ```
>
>
>
>
Which can be [tested here](http://www.online-utility.org/math/math_calculator.jsp), the matrix needs to be in the format `a = [row ; row ; row ; ...]`
[Answer]
# Python: 192 Characters (not including whitespace)
```
import itertools
def l(a,i,r):
s=[b for b in r if a[i][b]]
k=len(s)
if k<2:
return 0
return 2.0*sum(map(lambda x:a[x[0]][x[1]],itertools.combinations(s,2)))/k/(k-1)
def g(a):
n=len(a)
r=range(n)
return sum([l(a,i,r) for i in r])/n
```
# Example Usage:
```
>>> g([[1, 1, 1], [1, 1, 1], [1, 1, 1]])
1.0
>>> g([[0, 1, 0, 0, 0, 1, 0, 0],
[1, 0, 1, 1, 1, 0, 1, 0],
[0, 1, 0, 0, 0, 1, 0, 0],
[0, 1, 0, 0, 1, 0, 0, 0],
[0, 1, 0, 1, 0, 1, 1, 0],
[1, 0, 1, 0, 1, 0, 0, 1],
[0, 1, 0, 0, 1, 0, 0, 1],
[0, 0, 0, 0, 0, 1, 1, 0]])
0.233333333333
>>> g([[0, 1, 0, 0, 1],
[1, 0, 1, 0, 0],
[0, 1, 0, 1, 0],
[0, 0, 1, 0, 1],
[1, 0, 0, 1, 0]])
0.0
>>> g([[0,1,1,1,0,1,1,1,1,0,1,0,0,0,1,0,0,0,0,1],
[1,0,0,0,1,0,0,0,1,1,1,1,0,1,0,0,1,0,0,1],
[1,0,0,1,1,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0],
[1,0,1,0,0,0,0,1,1,1,0,1,0,1,1,1,0,0,0,1],
[0,1,1,0,0,1,0,1,1,0,0,0,0,1,0,0,0,0,1,0],
[1,0,1,0,1,0,0,1,0,0,1,1,0,0,0,1,0,1,1,1],
[1,0,0,0,0,0,0,1,1,0,0,1,1,0,1,1,0,0,1,0],
[1,0,0,1,1,1,1,0,1,1,0,0,0,0,0,0,1,0,0,0],
[1,1,1,1,1,0,1,1,0,0,1,0,1,0,0,0,1,0,1,0],
[0,1,0,1,0,0,0,1,0,0,1,0,0,0,0,1,0,1,0,0],
[1,1,0,0,0,1,0,0,1,1,0,0,1,0,0,0,0,1,1,0],
[0,1,0,1,0,1,1,0,0,0,0,0,1,1,1,1,0,1,0,0],
[0,0,0,0,0,0,1,0,1,0,1,1,0,0,1,0,1,1,0,1],
[0,1,0,1,1,0,0,0,0,0,0,1,0,0,0,0,1,1,1,0],
[1,0,0,1,0,0,1,0,0,0,0,1,1,0,0,1,1,1,1,0],
[0,0,0,1,0,1,1,0,0,1,0,1,0,0,1,0,0,0,1,1],
[0,1,0,0,0,0,0,1,1,0,0,0,1,1,1,0,0,0,1,1],
[0,0,0,0,0,1,0,0,0,1,1,1,1,1,1,0,0,0,0,0],
[0,0,1,0,1,1,1,0,1,0,1,0,0,1,1,1,1,0,0,1],
[1,1,0,1,0,1,0,0,0,0,0,0,1,0,0,1,1,0,1,0]])
0.389888167388
>>> g([[0,1,1],
[1,0,0],
[1,0,0]])
0.0
```
] |
[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/4483/edit).
Closed 2 years ago.
[Improve this question](/posts/4483/edit)
Given a list of nested menu items,
```
items = [
'3D/Axis',
'3D/CameraTracker',
'Color/Invert',
'Color/Log2Lin',
'Color/Math/Add',
'Color/Math/Multiply',
'Other/Group',
'Other/NoOp',
'Views/JoinViews',
'Views/ShuffleViews',
'Views/Stereo/Anaglyph',
'Views/Stereo/ReConverge',
]
```
..and a dummy function to be triggered by each item:
```
def msg(path):
"""Dummy function used in menu
"""
return path.lower()
```
Programatically create a hierarchal collection of dictionaries, which is equivalent to manually typing this:
```
menu = {
'3D': {'Axis': lambda: msg('3D/Axis'),
'CameraTracker': lambda: msg("3D/CameraTracker")},
'Color': {'Invert': lambda: msg('Color/Invert'),
'Log2Lin': lambda: msg('Color/Log2Lin'),
'Math': {'Add': lambda: msg('Color/Add'),
'Multiply': lambda: msg('Color/Multiply')}},
'Other': {'Group': lambda: msg('Other/Group'),
'NoOp': lambda: msg('Other/NoOp')},
'Views': {'JoinViews': lambda: msg('Views/JoinViews'),
'ShuffleViews': lambda: msg('Views/ShuffleViews'),
'Stereo': {'Anaglyph': lambda: msg('Views/Stereo/Anaglyph'),
'ReConverge': lambda: msg('Views/Stereo/ReConverge')}}},
```
..which could be tested as follows:
```
assert menu['3D']['Axis']() == '3d/axis'
assert menu['Color']['Invert']() == 'color/invert'
assert menu['Color']['Math']['Add']() == 'color/math/add'
assert menu['Views']['Stereo']['Anaglyph']() == 'views/stereo/anaglyph'
```
[Answer]
A simple recursion will do the work
```
def build_nested_helper(path, text, container):
segs = path.split('/')
head = segs[0]
tail = segs[1:]
if not tail:
container[head] = lambda: msg(text)
else:
if head not in container:
container[head] = {}
build_nested_helper('/'.join(tail), text, container[head])
def build_nested(paths):
container = {}
for path in paths:
build_nested_helper(path, path, container)
return container
menu = build_nested(items)
```
squashed code: 159 chars
```
def f(p,t,c):
s=p.split('/');a=s[0];b=s[1:]
if b:
if a not in c:c[a]={}
f('/'.join(b),t,c[a])
else:c[a]=lambda:msg(t)
menu={}
for i in items:f(i,i,menu)
```
[Answer]
```
#!/usr/bin/env python3
from itertools import groupby
from pprint import pprint
items = [
'3D/Axis',
'3D/CameraTracker',
'Color/Invert',
'Color/Log2Lin',
'Color/Math/Add',
'Color/Math/Multiply',
'Other/Group',
'Other/NoOp',
'Views/JoinViews',
'Views/ShuffleViews',
'Views/Stereo/Anaglyph',
'Views/Stereo/ReConverge',
]
def fun(group, items, path):
sep = lambda i:i.split('/', 1)
head = [i for i in items if len(sep(i))==2]
tail = [i for i in items if len(sep(i))==1]
gv = groupby(sorted(head), lambda i:sep(i)[0])
return group, dict([(i, path+i) for i in tail] + [fun(g, [sep(i)[1] for i in v], path+g+'/') for g,v in gv])
menu = dict([fun('menu', items, '')])['menu']
pprint(menu)
```
---
```
{'3D': {'Axis': '3D/Axis', 'CameraTracker': '3D/CameraTracker'},
'Color': {'Invert': 'Color/Invert',
'Log2Lin': 'Color/Log2Lin',
'Math': {'Add': 'Color/Math/Add',
'Multiply': 'Color/Math/Multiply'}},
'Other': {'Group': 'Other/Group', 'NoOp': 'Other/NoOp'},
'Views': {'JoinViews': 'Views/JoinViews',
'ShuffleViews': 'Views/ShuffleViews',
'Stereo': {'Anaglyph': 'Views/Stereo/Anaglyph',
'ReConverge': 'Views/Stereo/ReConverge'}}}
```
---
**`fun()` takes 6 lines**
Just change `path+i` to `(path+i).lower()` to get what you want.
[Answer]
# [JavaScript (V8)](https://v8.dev/), 134 bytes
```
menu=items.reduce((a,x,_,$,c=a,s=x.split`/`)=>s.slice(0,-1).map(v=>c=c[v]?c[v]:c[v]={})&&(c[s[s.length-1]]=()=>x.toLowerCase())&&a,{})
```
[Try it online!](https://tio.run/##hZFRS8MwFIXf9yv2IGsLWev0RYRMRgVRNgcqvpTiQnrXRtOmJGnXIf72mqZ2sImYh5Cc893QnvNOaqKoZKWe1lct05CrMR5Ho7FZzuVtsGiYctDhGpIcJHmRhH6ANHpvhIILGdwXNUg9wL22FOnFkhUn5IroLFgkyTFr1VXFNSv5/jCx1hnI4E6KqhzwXnoU6/JAvTLYqeBBsMKeBrKXn7Nqu@UwOEeWBgkiWBQk5fsyO5nrzScIRfdrKRg7bnMoKmyD8iUkFQXXJahBb@gMUUyQwo2vSs70Jth4eK58xZlhztF05vk5Kd0azymmUR3fdNt1t@HPL28ycWmkIuVzKFKdTWdxjF3zQONrsRQ7kCFR4HqGI8jgLRWFEhx8LlK3@6TI1OPEkWMLiw04@k3YnDvop6r/sK4R@6ap6g@2D9UwfViWHsLsRtpv "JavaScript (V8) – Try It Online")
[Answer]
As a starting point,
```
def populate_dict(item, existing_dict, fullpath = None):
if len(item) == 1:
existing_dict[item[0]] = lambda p=item[0]: msg(fullpath + "/" + item[0])
else:
head, tail = item[0], item[1:]
existing_dict.setdefault(head, {})
populate_dict(
tail,
existing_dict[head],
fullpath = "/".join([x for x in (fullpath, head) if x is not None]))
menu = {}
for i in items:
populate_dict(i.split("/"), menu)
```
..which can be squashed down to:
```
def p(i,e,fp=""):
if len(i)<2:e[i[0]]=lambda p=i[0]:msg(fp+"/"+i[0])
else:p(i[1:], e.setdefault(i[0], {}),"/".join([fp, i[0]]).lstrip("/"))
menu = {}
for i in items:p(i.split("/"),menu)
```
] |
[Question]
[
Your function must have an input that takes in an array containing 10000 random names, and must sort these names in alphabetical order. Names have a random length of up to 128 characters. ISO/IEC 8859-1 character set assumed to be used for the list of names.
Usable list of names can be found at <http://www.opensourcecf.com/1/2009/05/10000-Random-Names-Database.cfm> (firstNameFirst column).
You may not use any native sorting functions available to your language.
The winner will be based purely on speed.
Language used must be compilable/runnable on a standard \*nix box.
[Answer]
## C - [B-tree](http://en.wikipedia.org/wiki/B-tree) sort
This sorts randomNames.csv in about 5.8ms on my Core 2 T5500 @ 1.66GHz. My testing utility is [here](https://gist.github.com/930486#file_gistfile1.c).
It isn't the fastest algorithm for sorting this quantity of data, but I didn't feel like [trie](http://en.wikipedia.org/wiki/Trie)ing.
```
#include <assert.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct Btree Btree;
static void btree_insert(Btree **btree, const char *key);
static void btree_emit_and_free(Btree *btree, const char ***out);
void sort(const char **strings, size_t count, const char **out)
{
size_t i;
Btree *tree = NULL;
const char **out_start = out;
for (i = 0; i < count; i++)
btree_insert(&tree, strings[i]);
btree_emit_and_free(tree, &out);
assert(out - out_start == (ssize_t) count);
}
/*
* Maximum (U) and minimum (L) number of *keys* per B-tree node.
*
* The maximum number of *branches* a B-tree may have is U+1 :
*
* KEY KEY
* / | \
* branch branch branch
*/
#define U 20
#define L (U / 2)
struct Btree {
/* Number of keys (rather than branches). */
unsigned char count;
/* 0 if node is a leaf, 1 if it has leaf children, etc. */
unsigned char depth;
const char *keys[U];
/* Allocated to U+1 items if this is an internal node. */
Btree *branches[];
};
static Btree *allocLeaf(void)
{
return malloc(sizeof(Btree));
}
static Btree *allocInternal(void)
{
return malloc(sizeof(Btree) + (U+1) * sizeof(Btree *));
}
static bool insert(Btree *node, const char *x,
const char **new_x, Btree **new_xr);
static bool insert_item(Btree *node, unsigned int k,
const char *x, Btree *xr,
const char **new_x, Btree **new_xr);
static unsigned int
find_insertion_point(const char *keys[], unsigned int count, const char *x);
static void btree_insert(Btree **btree, const char *key)
{
if (*btree == NULL) {
Btree *root = allocLeaf();
root->count = 1;
root->depth = 0;
root->keys[0] = key;
*btree = root;
} else {
const char *new_x;
Btree *new_xr;
if (insert(*btree, key, &new_x, &new_xr)) {
Btree *root = allocInternal();
root->count = 1;
root->depth = (*btree)->depth + 1;
root->keys[0] = new_x;
root->branches[0] = *btree;
root->branches[1] = new_xr;
*btree = root;
}
}
}
static bool insert(Btree *node, const char *x,
const char **new_x, Btree **new_xr)
{
unsigned int k = find_insertion_point(node->keys, node->count, x);
Btree *xr;
if (node->depth == 0)
xr = NULL;
else if (insert(node->branches[k], x, new_x, new_xr))
x = *new_x, xr = *new_xr;
else
return false;
return insert_item(node, k, x, xr, new_x, new_xr);
}
static bool insert_item(Btree *node, unsigned int k,
const char *x, Btree *xr,
const char **new_x, Btree **new_xr)
{
unsigned int i;
bool internal = xr != NULL;
if (node->count < U) {
/* Enough case */
for (i = node->count; i-- > k;)
node->keys[i + 1] = node->keys[i];
node->keys[k] = x;
if (internal) {
for (i = node->count + 1; i-- > k + 1;)
node->branches[i + 1] = node->branches[i];
node->branches[k + 1] = xr;
}
node->count++;
return false;
} else {
Btree *r = internal ? allocInternal() : allocLeaf();
node->count = L;
r->count = L;
r->depth = node->depth;
if (k < L) {
/* Left case */
*new_x = node->keys[L - 1];
for (i = 0; i < L; i++)
r->keys[i] = node->keys[i + L];
for (i = L - 1; i-- > k;)
node->keys[i + 1] = node->keys[i];
node->keys[k] = x;
if (internal) {
for (i = 0; i <= L; i++)
r->branches[i] = node->branches[i + L];
for (i = L; i-- > k + 1;)
node->branches[i + 1] = node->branches[i];
node->branches[k + 1] = xr;
}
} else if (k == L) {
/* Central case */
*new_x = x;
for (i = 0; i < L; i++)
r->keys[i] = node->keys[i + L];
if (internal) {
r->branches[0] = xr;
for (i = 1; i <= L; i++)
r->branches[i] = node->branches[i + L];
}
} else {
/* Right case */
*new_x = node->keys[L];
for (i = 0; i < k - L - 1; i++)
r->keys[i] = node->keys[i + L + 1];
r->keys[k - L - 1] = x;
for (i = k - L; i < L; i++)
r->keys[i] = node->keys[i + L];
if (internal) {
for (i = 0; i < k - L; i++)
r->branches[i] = node->branches[i + L + 1];
r->branches[k - L] = xr;
for (i = k - L + 1; i <= L; i++)
r->branches[i] = node->branches[i + L];
}
}
*new_xr = r;
return true;
}
}
static unsigned int
find_insertion_point(const char *keys[], unsigned int count, const char *x)
{
unsigned int start = 0;
unsigned int middle;
while (count) {
middle = count >> 1;
if (strcmp(x, keys[start + middle]) < 0) {
count = middle;
} else {
start += middle + 1;
count -= middle + 1;
}
}
return start;
}
static void btree_emit_and_free(Btree *btree, const char ***out)
{
unsigned int i;
if (btree->depth == 0) {
for (i = 0; i < btree->count; i++)
*(*out)++ = btree->keys[i];
} else {
for (i = 0; i < btree->count; i++) {
btree_emit_and_free(btree->branches[i], out);
*(*out)++ = btree->keys[i];
}
btree_emit_and_free(btree->branches[btree->count], out);
}
free(btree);
}
```
] |
[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 12 months ago.
[Improve this question](/posts/258198/edit)
I'm working from home and the heat of my laptop on my lap is the only thing keeping me warm. I have a Dell G3 Laptop with an NVidia GEForce GTX CPU.
I have tried writing a rust program with 5 threads that calculates and prints the Fibonacci sequence in an infinite unthrottled loop, but that only gave a bit of warmth, and eventually gave an overflow panic. I've tried running the `ai_benchmark` python module benchmarks in a loop but that was even worse. Using pip to download tensorflow has given me the most warmth so far for some reason.
The winner will be the warmest program, or in case of a draw, the shortest warmest program. The deadline is 30 minutes. I'm cold!
]
|
[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 last year.
[Improve this question](/posts/255796/edit)
[Strassen's algorithm](https://en.wikipedia.org/wiki/Strassen_algorithm) was the first method of matrix multiplication in subcubic time complexity, namely `O(n**log2(7))` for a pair of `n*n` matrices (assuming the numbers therein are large enough that their `O(n*log2(n))` exact multiplication has become the constraint on your performance, and any nested structures and function calls are negligible in comparison).
For a `2*2` matrix, it is defined as
```
lambda a,b: (lambda a,b,c,d,e,f,g: (a+d-e+g,c+e,b+d,a-b+c+f))((a[0]+a[3])*(b[0]+b[3]),(a[2]+a[3])*b[0],a[0]*(b[1]-b[3]),a[3]*(b[2]-b[0]),(a[0]+a[1])*b[3],(a[2]-a[0])*(b[0]+b[1]),(a[1]-a[3])*(b[2]+b[3]))
```
And for larger square ones, as splitting them into quarters and then calling this but with numbers' addition, negation and multiplication methods substituted for matrices' (notably using itself for the latter, its seven self-calls per doubling of the width and height being the reason for the exponent).
For simplicity (so you won't need to deal with implementing standard matrix multiplication and subdividing into Strassen-able ones), your inputs will be two `2**n*2**n` matrices of integers, represented as length-`2**(2*n)` tuples (or lists or your language's equivalent), encoded with elements in reading order, and you will return another such tuple. For instance, when inputted with these two
```
(5,2,0,0,
4,0,5,2,
3,4,5,0,
3,1,4,2)
(7,4,5,3,
4,0,2,7,
1,4,1,1,
0,5,3,5)
```
, it should return
```
(43,20,29,29,
33,46,31,27,
42,32,28,42,
29,38,27,30)
```
[Answer]
# One-line Python (1027 bytes)
(explained in [this gist](https://gist.github.com/DroneBetter/b184fbff57077de3ec720d0a0add9ff2), would be greatly reducible if you were to be less pedantic about it all being one line)
```
from functools import reduce
from math import isqrt
from random import random
lap=(lambda f,*a: list(map(f,*a)))
strassen=(lambda a,b: tuple((lambda f: f(a,b) if len(a)==4 else (lambda m: (lambda m,d: ((m[y*2+x][d*j+i] for y in range(2) for j in range(d) for x in range(2) for i in range(d))))(m,isqrt(len(m[0]))))(f(*(map((lambda m: (lambda m,d: tuple((tuple((m[i*d+j] for i in range(d//2*y,d//(2-y)) for j in range(d//2*x,d//(2-x)))) for y in range(2) for x in range(2))))(m,isqrt(len(m)))),(a,b))))))((lambda a,b: (lambda s,n,o,m: (lambda a,b,c,d,e,f,g: lap(s,((a,d,n(e),g),(c,e),(b,d),(a,n(b),c,f))))(*map(m,*map(lambda x: map(o,x),(((a[0],a[3]),(a[2],a[3]),(a[0],),(a[3],),(a[0],a[1]),(a[2],n(a[0])),(a[1],n(a[3]))),((b[0],b[3]),(b[0],),(b[1],n(b[3])),(b[2],n(b[0])),(b[3],),(b[0],b[1]),(b[2],b[3])))))))(*((sum,int.__neg__,sum,int.__mul__) if type(a[0])==int else ((lambda x: reduce(lambda a,b: lap(int.__add__,a,b),x)),(lambda x: map(int.__neg__,x)),(lambda t: t[0] if len(t)==1 else lap(int.__add__,*t)),strassen)))))))
```
] |
[Question]
[
Does anyone have tips on how to golf in this language? Please one tip per answer and avoid posting simple and general tips such as "remove whitespace".
[Here](https://github.com/ZippyMagician/Arn) is the github link and [here](https://esolangs.org/wiki/Arn) is the esolang page.
]
|
[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/249573/edit).
Closed 1 year ago.
[Improve this question](/posts/249573/edit)
## Task
In this challenge, your task is to write a program or function which takes an array of paths with an additional boolean indicating it is a file or directory and outputs a file/directory tree in **any** reasonable format.
## Remarks
* Some directories can end with a forward slash (**"/"**) but this is not always the case
* A parent directory is not always explicitly defined but should be in the tree
* **"."** and **".."** as file name or directory name are not allowed
* Standard loopholes are not allowed
## Input
An unsorted array of paths. Each item is a tuple of path and a boolean which is True for a file and False for a directory.
```
[
['Root Folder/Sub Folder/', False],
['Root Folder/Sub Folder/hello.txt', True],
['Root Folder/Sub Folder/SubSub Folder/SubSubSub Folder/', False],
['Root Folder/Sub Folder/world.txt', True],
['Root Folder/Sub Folder 2', False],
]
```
## Output
### Text formatted example
```
[D] Root Folder
[D] Sub Folder
[D] SubSub Folder
[D] SubSubSub Folder
[F] hello.txt
[F] world.txt
[D] Sub Folder 2
```
### Data structure formatted example
```
[
'Root Folder',
[
[
'Sub Folder',
[
[
'SubSub Folder',
[
[
'SubSubSub Folder', [], []
]
],
[]
]
],
['hello.txt', 'world.txt']
],
[
'Sub Folder 2',
[],
[]
]
],
[]
]
```
This is a code golf. Shortest code in bytes wins.
]
|
[Question]
[
In Windows, when you perform double-click in a text, the word around your cursor in the text will be selected.
(This feature has more complicated properties, but they will not be required to be implemented for this challenge.)
For example, let `|` be your cursor in `abc de|f ghi`.
Then, when you double click, the substring `def` will be selected.
# Input/Output
You will be given two inputs: a string and an integer.
Your task is to return the word-substring of the string around the index specified by the integer.
Your cursor can be right **before** or right **after** the character in the string at the index specified.
If you use right **before**, please specify in your answer.
# Specifications (Specs)
The index is **guaranteed** to be inside a word, so no edge cases like `abc |def ghi` or `abc def| ghi`.
The string will **only** contain printable ASCII characters (from U+0020 to U+007E).
The word "word" is defined by the regex `(?<!\w)\w+(?!\w)`, where `\w` is defined by `[abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_]`, or "alphanumeric characters in ASCII including underscore".
The index can be 1-indexed **or** 0-indexed.
If you use 0-indexed, please specify it in your answer.
# Testcases
The testcases are 1-indexed, and the cursor is right **after** the index specified.
The cursor position is for demonstration purpose only, which will not be required to be outputted.
```
string index output cursor position
abc def 2 abc ab|c def
abc def 5 def abc d|ef
abc abc 2 abc ab|c abc
ab cd ef 4 cd ab c|d ef
ab cd 6 cd ab c|d
ab!cd 1 ab a|b!cd
```
[Answer]
# [V](https://github.com/DJMcMayhem/V), ~~10, 9~~ 7 bytes
```
À|diwVp
```
[Try it online!](http://v.tryitonline.net/#code=w4B8ZGl3VnA&input=YWJjIGRlZg&args=NQ)
This answer uses 1-based indexing.
This could be shorter if we do exactly what the title says: "*Select* the word around the given index in a string". We could do
```
À|viw
```
Which literally selects the word, but unfortunately doesn't change the output at all. So we need a little workaround to make it work by cutting it into a register, deleting the rest of the text, then pasting the register back in.
Explanation:
```
À| " Jump the position of argument 1
diw " (d)elete (i)nside this (w)ord.
V " Select this line
p " And replace it with the word we just deleted
```
[Answer]
# C, 104 bytes
```
p[99];i,d;main(l){for(scanf("%d",&i);scanf("%[^a-zA-Z0-9_]%[a-zA-Z0-9_]%n",&d,&p,&l),i>l;i-=l);puts(p);}
```
Expects the input on stdin to be the 0-based index followed by one space or newline, followed by the string. Maximal length for a word is 99 characters. E.g.:
```
2 abc def
```
[Answer]
# C (gcc), 94 bytes
```
f(n,p)char*p;{for(p+=n-1;isalnum(*p)|*p==95&&n--;--p);for(;isalnum(*++p)|*p==95;putchar(*p));}
```
Zero-indexed, defines a function taking the index, then the string.
[Answer]
## Retina, 22
```
(1)+¶(?<-1>.)*\b|\W.+
```
[Try it online!](http://retina.tryitonline.net/#code=KDEpK8K2KD88LTE-LikqXGJ8XFcuKwo&input=MTExMTEKYWJjIGRlZiBnaGk) or [verify all test cases](http://retina.tryitonline.net/#code=JShHYApTYFxcCl4uKwokKgooMSkrwrYoPzwtMT4uKSpcYnxcVy4rCg&input=MlxhYmMgZGVmCjVcYWJjIGRlZgoyXGFiYyBhYmMKNFxhYiBjZCBlZgo2XGFiICAgY2QKMVxhYiFjZA). The regular program takes the cursor position in unary followed by a newline and then the string. The test suite has additional code to run in per line mode, and uses a `\` as a delimiter, and it uses decimal, for convenience.
Uses balancing groups to find the cursor position, then backtracks up to a word boundary. Deletes the text up to the word, and then after the word.
[Answer]
# Pyth, 16 bytes
```
+e=:.<+QbE"\W"3h
Q first input (string)
+ b plus newline
.< E rotate left by second input (number)
: "\W"3 split on regex \W, non-word characters
= assign to Q
e last element
+ hQ plus first element
```
[Try it online](https://pyth.herokuapp.com/?code=%2Be%3D%3A.%3C%2BQbE%22%5CW%223h&input=3%0A%22foo+bar+baz%22&test_suite=1&test_suite_input=%22abc+def%22%0A2%0A%22abc+def%22%0A5%0A%22abc+abc%22%0A2%0A%22ab+cd+ef%22%0A4%0A%22ab+++cd%22%0A6%0A%22ab%21cd%22%0A1&input_size=2)
[Answer]
# [JavaScript (V8)](https://v8.dev/), 44 bytes
```
(i,x)=>RegExp(`\\w*(?<=.{${i}})`).exec(x)[0]
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNEts/ifZvtfI1OnQtPWLig13bWiQCMhJqZcS8PexlavWqU6s7ZWM0FTL7UiNVmjQjPaIPZ/QVFmXokGV5qGkY5SYlKyQkpqmpKmDpBvip0PxBC@CYivkJyiAFNgBhZQAApB@IYgviKIx6X5HwA "JavaScript (V8) – Try It Online")
This is longer than an existing JS solution, but I don't actually understand the approach it uses, and I wrote this prior to seeing that solution. Hopefully this is different enough to be interesting :P
Code explanation, so the same fate is not befallen upon ye
```
(i,x)=> take i (number) and x (string)
RegExp(`...${i}...`) construct a regex with i in it
.exec(x)[0] return the first result of that regex on the string
\w*(?<=.{i}) constructed regex
\w* match an entire word
(?<= ) if the end of the word comes after
.{i} at least i characters
```
[Answer]
# C, 115 bytes
Function `f()` requires the string and index (1-indexed) as parameters and prints the result to stdout. Cursor should be after the specified character.
```
f(char*p,int n){char*s=p+n;for(;s>=p&&isalnum(*s)+(*s==95);--s);for(p=s+1;*p&&isalnum(*p)+(*p==95);putchar(*p++));}
```
[Answer]
## JavaScript (ES6), 57 bytes
```
f=(s,n)=>s.slice(0,n).match(/\w*$/)+s.slice(n).match(/\w*/)
```
Simply slices the string at the cursor point (which is before the 0-indexed character, which works out the same as after the 1-indexed character), then extracts and concatenates the adjacent word fragments. Even returns a sensible result when the cursor is at the start, end, or nowhere near a word.
[Answer]
# Java 8, ~~86~~ 78 bytes
```
(s,p)->{for(String t:s.split("\\W"))if((p-=t.length()+1)<0)return t;return"";}
```
Ungolfed with test cases:
```
class Indexer {
public static String f(String s, int p) {
for(String t : s.split("\\W"))
if((p -= t.length()+1) < 0)
return t;
return "";
}
public static void main(String[] args) {
System.out.println(f("abc def",2));
System.out.println(f("abc def",5));
System.out.println(f("abc abc",2));
System.out.println(f("ab cd ef",4));
System.out.println(f("ab cd",6));
System.out.println(f("ab!cd",1));
}
}
```
Splits the string by non-alphanumeric characters, then keeps subtracting the length of each substring, plus 1, from the specified position, until it becomes negative. Since any repeating non-alphanumerics get represented as empty string, the subtraction logic is significantly easier.
This code isn't extensively tested, so I'd like to see if someone can break this. Also, considering that this is Java code, how is this not the longest answer here? :P
[Answer]
# Ruby, ~~41~~ 31 bytes
[Try it online!](https://repl.it/Cd3W/1)
*-10 bytes from @MartinEnder*
```
->s,i{s[/\w*(?<=^.{#{i}})\w*/]}
```
[Answer]
## Pyke, 19 bytes
```
#Q;cjmli<i+s)lttjR@
```
[Try it here!](http://pyke.catbus.co.uk/?code=%23Q%3Bcjmli%3Ci%2Bs%29lttjR%40&input=abc+def+a%0A9)
Uses `Q;` as a no-op to make sure the first input is placed correctly
```
# ) - first where
c - input.split()
ml - map(len, ^)
i< - ^[:i]
i+ - ^+[i]
s - sum(^)
lt - len(^)-2
```
[Answer]
# Python 2, ~~70~~ 66 bytes
```
import re
f=lambda x,y,r=re.split:r('\W',x[:y])[-1]+r('\W',x[y:])[0]
```
Splits the string by non-word separators, once on the original string up to the cursor index, then on the string beginning at the cursor index. Returns the last element of the left split plus the first element of the right split.
Thanks to Leaky Nun for saving 4 bytes!
[Answer]
# Clojure, 92 bytes
```
(fn[x k](let[[u i](map #(re-seq #"\w+"(apply str %))(split-at k x))](str(last u)(nth i 0))))
```
First, splits input string at position `k` into two strings. Then for these strings find occurrences of `"\w+"` and return them as list. Then concatenate the last element of first list and the first element of second list.
See it online: <https://ideone.com/Dk2FIs>
[Answer]
# JavaScript (ES6), 52 bytes
```
(s,n)=>RegExp(`^.{0,${n}}(\\W+|^)(\\w+)`).exec(s)[2]
```
```
const F = (s,n) => RegExp(`^.{0,${n}}(\\W+|^)(\\w+)`).exec(s)[2]
class Test extends React.Component {
constructor(props) {
super(props);
const input = props.input || '';
const index = props.index || 0;
this.state = {
input,
index,
valid: /\w/.test(input),
};
}
onInput = () => {
const input = this.refs.input.value;
const index = Math.min(+this.refs.index.value, input.length);
this.setState({
input,
index,
valid: /\w/.test(input),
});
}
render() {
const {input, index, valid} = this.state;
return (
<tr>
<td>{ this.props.children }</td>
<td>
<input ref="input" type="text" onInput={this.onInput} value={input} />
<input ref="index" type="number" onInput={this.onInput} min="1" max={input.length} value={index} />
</td>
{valid && [
<td>{F(input, index)}</td>,
<td><pre>{input.slice(0, index)}|{input.slice(index)}</pre></td>,
]}
</tr>
);
}
}
class TestList extends React.Component {
constructor(props) {
super(props);
this.tid = 0;
this.state = {
tests: (props.tests || []).map(test => Object.assign({
key: this.tid++
}, test)),
};
}
addTest = () => {
this.setState({
tests: [...this.state.tests, { key: this.tid++ }],
});
}
removeTest = key => {
this.setState({
tests: this.state.tests.filter(test => test.key !== key),
});
}
render() {
return (
<div>
<table>
<thead>
<th/>
<th>Test</th>
<th>Output</th>
<th>Diagram</th>
</thead>
<tbody>
{
this.state.tests.map(test => (
<Test key={test.key} input={test.input} index={test.index}>
<button onClick={() => this.removeTest(test.key)} style={{
verticalAlign: 'middle',
}}>-</button>
</Test>
))
}
</tbody>
<tfoot>
<td/>
<td>
<button onClick={this.addTest} style={{
width: '100%',
}}>Add test case</button>
</td>
</tfoot>
</table>
</div>
);
}
}
ReactDOM.render(<TestList tests={[
{ input: 'abc def', index: 2 },
{ input: 'abc def', index: 5 },
{ input: 'abc abc', index: 2 },
{ input: 'ab cd ef', index: 4 },
{ input: 'ab cd', index: 6 },
{ input: 'ab!cd', index: 1 },
]} />, document.body);
```
```
input[type="number"] {
width: 3em;
}
table {
border-spacing: 0.5em 0;
border-collapse: separate;
margin: 0 -0.5em ;
}
td, input {
font-family: monospace;
}
th {
text-align: left;
}
tbody {
padding: 1em 0;
}
pre {
margin: 0;
}
```
```
<script src="https://cdnjs.cloudflare.com/ajax/libs/react/15.1.0/react.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/react/15.1.0/react-dom.min.js"></script>
```
[Answer]
## Lua, ~~71~~ 67 Bytes
Woohoo, Lua isn't the longest solution! Still one byte behind python, but don't know how to golf this down. Indexes are 1-based.
**Thanks to @LeakyNun reminding me the existence of `string.match`, saved 4 bytes**
```
g,h=...print(g:sub(1,h):match"[%a_]*$"..g:sub(h+1):match("[%a_]+"))
```
### Old 71
**Note: the explanations are still based on this one, because it also applies to the new one, but contains some extra informations on `gmatch`**
```
g,h=...print(g:sub(1,h):gmatch"[%a_]*$"()..g:sub(h+1):gmatch"[%a_]*"())
```
### Explanation
First, we unpack the arguments into `g` and `h` because they are shorter than `arg[x]`
```
g,h=...
```
Then, we construct our output, which is the concatanation of the part before the cursor and after it.
The first part of the string is
```
g:sub(1,h)
```
We want to find the word at the end of this one, so we use the function `string.gmatch`
```
:gmatch"[%a_]*$"
```
This pattern match `0..n` times the character set of alphabet+underscore at the end of the string. `gmatch` returns an iterator on its list of match in the form of a function (using the principle of closure), so we execute it once to get the first part of our word
```
g:sub(1,h):gmatch"[%a_]*$"()
```
We get the second part of our word by the same way
```
g:sub(h+1):gmatch"[%a_]*"())
```
The only difference being we don't have to specify we want to match at the start of the string (using `[^%a_]*`), as it will be the match returned by the iterator when it's called the first time.
[Answer]
# JavaScript (ES 6), ~~43~~42 Bytes
```
s=>n=>s.replace(/\w*/g,(x,y)=>y<n?s=x:0)&&s
```
# JavaScript (ES 3), 65 Bytes
```
function(s,n){s.replace(/\w*/g,function(x,y){y<n?s=x:0});alert(s)}
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 14 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
ð«._DžjмS¡Á2£J
```
Port of [*@AndersKaseorg*'s Pyth answer](https://codegolf.stackexchange.com/a/85770/52210).
1-indexed like the challenge test cases.
[Try it online](https://tio.run/##ASYA2f9vc2FiaWX//8OwwqsuX0TFvmrQvFPCocOBMsKjSv//YWIhY2QKNA) or [verify all test cases](https://tio.run/##yy9OTMpM/V9Waa@k8KhtkoKSfWVQwv/DGw6t1ot3Obov68Ke4EMLDzcaHVrs9V/nf3S0UmJSskJKapqSjlGsjgIS1xTOBWKErEJyigJI2gTGVwCKKOmYQbmKII4hMgei0NDIWMXUzFzL0kBJxzI2FgA).
**Explanation:**
```
ð« # Append a space to the (implicit) input-String
._ # Rotate this string the (implicit) input-integer amount of times
# towards the left
D # Duplicate this string
žjм # Remove [a-zA-Z0-9_] from the string
S¡ # Split the rotated string by each of the remaining characters
Á # Rotate the resulting list once towards the right
2£J # And only leave the first two items, joined together
# (which is output implicitly)
```
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 34 bytes
```
->\b{&{first *.to>b,m:g/<<\w+>>/}}
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPtf1y4mqVqtOi2zqLhEQUuvJN8uSSfXKl3fxiamXNvOTr@29n9xYqVCmoaRpoZSYlKyQkpqmpKmNRdE0BSbIEwlECMETcCCCskpCshKzSCiCkBxhKAhWFARLPQfAA "Perl 6 – Try It Online")
Anonymous codeblock that takes input curried, like `f(n)(string)`.
### Explanation:
```
->\b{ } # Anonymous code block that takes a number
&{ } # And returns another code block that
first ,m:g/<<\w+>>/ # Finds the first word in the input
*.to>b # Where the start is after the number
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), 30 bytes
```
->s,n{s[/.{#{n}}\w+/][/\w+$/]}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf165YJ6@6OFpfr1q5Oq@2NqZcWz82Wh9IqejH1v4vUEiLVk9MUkhOUUhNU9dRMIn9DwA "Ruby – Try It Online")
A different approach, only 1 byte shorter and 3 years later. Why not?
[Answer]
# APL(NARS), 58 chars, 116 bytes
```
{m←⎕A,⎕a,⎕D,'_'⋄↑v⊂⍨m∊⍨v←⍵↓⍨¯1+⍵{⍵≤1:⍵⋄m∊⍨⍵⊃⍺:⍺∇⍵-1⋄⍵+1}⍺}
```
⍵{⍵≤1:⍵⋄m∊⍨⍵⊃⍺:⍺∇⍵-1⋄⍵+1}⍺ find where start the string...How to use and test:
```
f←{m←⎕A,⎕a,⎕D,'_'⋄↑v⊂⍨m∊⍨v←⍵↓⍨¯1+⍵{⍵≤1:⍵⋄m∊⍨⍵⊃⍺:⍺∇⍵-1⋄⍵+1}⍺}
2 f 'abc def'
abc
5 f 'abc def'
def
2 f 'abc abc'
abc
4 f 'ab cd ef'
cd
1 f 'ab!cd'
ab
6 f 'ab cd'
cd
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 12 bytes
```
Żṙe€ØW¬œpƊ.ị
```
[Try it online!](https://tio.run/##y0rNyan8///o7oc7Z6Y@alpzeEb4oTVHJxcc69J7uLv7/@Hl@pqR//9HKyUmJSukpKYp6SgYxeooIPNN4XwgRpJXSE5RACswgQkoAIWAfDMoXxHMM4wFAA "Jelly – Try It Online")
Port of [Anders Kaseorg's Pyth answer](https://codegolf.stackexchange.com/a/85770/85334).
```
Ż Prepend a zero as a buffer between the first and last words,
ṙ then rotate left by the index.
œpƊ Partition that result around
€ ¬ elements which are not
e ØW word characters,
.ị then take the last and first slices
and smash-print them together.
```
Original:
# [Jelly](https://github.com/DennisMitchell/jelly), 14 bytes
```
xðe€ØW¬Ä÷Ɗ=ị@¥
```
[Try it online!](https://tio.run/##y0rNyan8/7/i8IbUR01rDs8IP7TmcMvh7ce6bB/u7nY4tPT/4eX6mpH//0crJSYlK6SkpinpKBjF6igg803hfCBGkldITlEAKzCBCSgAhYB8MyhfEcwzjAUA "Jelly – Try It Online")
```
eۯW For each element, is it a word character?
Ä Take the cumulative sum
¬ of the negations
÷Ɗ and divide by the original Booleans.
= For each value in the result, is it equal to
ị@¥ the one at the index?
xð Filter the string to truthy positions.
```
[Answer]
# [MATL](https://github.com/lmendo/MATL), ~~16~~ 15 bytes
```
'\w+'5B#XXi>)1)
```
Cursor is 1-indexed and after the character (as in the test cases).
[Try it online!](http://matl.tryitonline.net/#code=J1x3Kyc1QiNYWGk-KTEp&input=J2FiIGNkIGVmJwo0) Or [verify all test cases](http://matl.tryitonline.net/#code=YAonXHcrJzVCI1hYaT4pMSkKRFQ&input=J2FiYyBkZWYnCjIKJ2FiYyBkZWYnCjUKJ2FiYyBhYmMnCjIKJ2FiIGNkIGVmJwo0CidhYiAgIGNkJwo2CidhYiFjZCcKMQ).
```
'\w+' % Push string to be used as regex pattern
5B#XX % Take input string implicitly. Apply regex. Push matches and ending indices
i> % Take input number. Compare with obtained ending indices. Gives true for
% ending indices that exceed the input number
) % Use as logical index to select the corresponding matches
1) % Select the first match. Implicitly display
```
[Answer]
## PowerShell v3+, ~~103~~ 101 bytes
```
param($a,$n)for(;$n[++$a]-match'\w'){}$i=$a--;for(;$n[--$a]-match'\w'-and$a-ge0){}-join$n[++$a..--$i]
```
Kind of a goofy solution, but a different approach than others.
Takes input `$a` as the 0-based index of the string `$n`. Then, we find the boundaries of our word. While we've not reached the end of the string and/or we're still matching word-characters, we `++$a`. Then, because of fenceposting, we set `$i=$a--`. Next, we crawl backwards, decrementing `$a` until it's either `0` or we hit a non-word-character. We then slice the input string based on those two demarcations (with some increment/decrements to account for OBOE), and `-join` it together to produce the result.
### Examples
```
PS C:\Tools\Scripts\golfing> .\select-the-word-around-the-index.ps1 2 'This!test'
This
PS C:\Tools\Scripts\golfing> .\select-the-word-around-the-index.ps1 5 'This!test'
test
```
[Answer]
# PHP, 98 bytes
```
function f($s,$p){foreach(preg_split('#\W+#',$s,-1,4)as$m)if($m[1]+strlen($m[0])>=$p)return$m[0];}
```
* splits the string by non-word-characters, remembering their position (`4` == `PREG_SPLIT_OFFSET_CAPTURE`), loops through the words until position is reached.
* PHP strings are 0-indexed, cursor before character, but may be before or after the word
[Answer]
## Python 3, ~~112~~ 140 bytes
```
from string import*
p='_'+printable[:62]
def f(s,h,r=''):
while s[h]in p and h>-1:h-=1
while h+1<len(s)and s[h]in p:h+=1;r+=s[h]
return r
```
0-indexed.
Seeks backward to the first alphanumeric character from the index, then goes forward to the last alphanumeric character after the index. There's probably a smarter way to do this.
[Try it](https://repl.it/CdJX/0)
[Answer]
## Javascript (using external library) (168 bytes)
```
(n,w)=> _.From(w).Select((x,i)=>({i:i,x:x})).Split((i,v)=>v.x==" ").Where(a=>a.Min(i=>i.i)<=n-1&&a.Max(i=>i.i)>=n-2).First().Select(i=>i.x).Write("").match(/^\w*^\w*/)[0]
```
Link to lib:<https://github.com/mvegh1/Enumerable/blob/master/linq.js>
Explanation of code: Library accepts a string, which gets parsed into a char array. It gets mapped to an object storing the index and the char. The sequence is split into subsequences at every occurrence of " ". The subsequences are filtered by checking if the cursor index is contained within the min and max index of the subsequence. Then we take the first subsequence. Then we transform back to just a char array. Then we concatenate all characters with "" as the delimiter. Then we validate against word regex. Then we take the first match.
[](https://i.stack.imgur.com/9WXAn.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/243707/edit).
Closed 1 year ago.
[Improve this question](/posts/243707/edit)
Imagine there is a card game where the primary objective of the game is to get 4 of one card in your hand.
### Game mechanics
Each player starts of with 10 cards in their hand. The remaining 32 cards (jokers are taken out of the deck) are put in the center.
Each turn, a player can put one of their cards (*which is chosen at random*) at the bottom of the deck and draw one from the top. They roll a fair, six sided die to determine how many times they do this in one turn.
### Card notation
As Penguino helpfully pointed out, suite is irrelevant, so cards are numbered 1 - 13, where 1 is Ace and 13 is King.
Write a program that takes in two arguments: Each players starting hand and Number of turns and return the probability that a player will get four of the same number in your hand within n turns.
## Examples to try
```
[[1,2,3,4,5,6,7,8,9,10],[13,12,11,10,9,8,7,6,5,4],10]
```
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so fewest bytes wins!
]
|
[Question]
[
[Cops thread (read first)](https://codegolf.stackexchange.com/questions/243503/hello-shue-cops)
Robbers, your task is to find a [Shue](https://codegolf.stackexchange.com/questions/242897/golf-the-prime-numbers-in-shue) program `p` that when given the cops input `i`, outputs a program `h`, which outputs "Hello Shue!". The length of your `p` has to be less than or equal to the length of the cop's `p`. The robber with the most cracks wins.
]
|
[Question]
[
**This question already has answers here**:
[Shortest code to produce non-deterministic output](/questions/101638/shortest-code-to-produce-non-deterministic-output)
(131 answers)
[Shortest code to produce infinite output](/questions/13152/shortest-code-to-produce-infinite-output)
(333 answers)
Closed 2 years ago.
## Task
---
Continuously print a random character `(a-z, A-Z, 0-9)` not separated by a newline (`\n`).
### Expected output
---
```
b7gFDRtgFc67h90h8H76f5dD55f7GJ6GRT86hG7TH6T7302f2f4 ...
```
*Note: output should be randomised.*
## Requirements/Rules
---
1. Output must be continuous (i.e. never ending),
2. Output may not comprise of newlines,
3. Output must be random, and should not have a set seed (i.e: produce the same output every time)
4. Output must be only composed of characters: a-z, A-Z, 0-9.
5. **No loopholes**, regarding programming language version(s). Use only the tools available with that programming language, no third-party packages, modules, or other addons.
## Points
---
* Smallest file size (in bytes)
]
|
[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/210639/edit).
Closed 3 years ago.
[Improve this question](/posts/210639/edit)
**This is the robbers' thread. The cops' thread is located [here](https://codegolf.stackexchange.com/questions/210638/cops-theres-a-fault-in-my-vault).**
## Robber rules
* Should work for all keys and secrets
* Should require the same number or fewer guesses as the cop's fault, to prevent brute forcing
* Does not need to be the same as the cop's intended fault
* Multiple cracks may be made for the same cop, as long as they use different methods
## Find Uncracked Cops
```
<script>site = 'meta.codegolf'; postID = 5686; isAnswer = false; QUESTION_ID = 210638;</script><script src='https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js'></script><script>jQuery(function(){var u='https://api.stackexchange.com/2.2/';if(isAnswer)u+='answers/'+postID+'?order=asc&sort=creation&site='+site+'&filter=!GeEyUcJFJeRCD';else u+='questions/'+postID+'?order=asc&sort=creation&site='+site+'&filter=!GeEyUcJFJO6t)';jQuery.get(u,function(b){function d(s){return jQuery('<textarea>').html(s).text()};function r(l){return new RegExp('<pre class="snippet-code-'+l+'\\b[^>]*><code>([\\s\\S]*?)</code></pre>')};b=b.items[0].body;var j=r('js').exec(b),c=r('css').exec(b),h=r('html').exec(b);if(c!==null)jQuery('head').append(jQuery('<style>').text(d(c[1])));if (h!==null)jQuery('body').append(d(h[1]));if(j!==null)jQuery('body').append(jQuery('<script>').text(d(j[1])))})})</script>
```
]
|
[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 3 years ago.
[Improve this question](/posts/208929/edit)
I am looking for a more efficient way of computing the following.
Let `A` and `B` be two vectors of non-negative integers of length `a` and `b`.
Let `A0` and `B0` be the padded versions of `A` and `B`, so that we pad the vectors by 0, until their lengths are `a+b`.
We now want to compute `sort(A0 + pB0)` where `pB0` ranges over all *distinct* permutations of `B0`, and keep track of how many times a result is obtained.
For example, `A={2,1,1}`, `B={3,1}` gives `A0={2,1,1,0,0}`, `B0={3,1,0,0,0}`,
and the expected output is
```
{{5,2,1},2}
{{5,1,1,1},2}
{{4,3,1},2}
{{3,3,1,1},2}
{{4,2,2},2}
{{4,2,1,1},4}
{{3,2,2,1},4}
{{3,2,1,1,1},2}
```
For example, {5,2,1} is obtained from the two cases
{2,1,1,0,0}+{3,1,0,0,0} and {2,1,1,0,0}+{3,0,1,0,0}.
The Mathematica code I use for generating this is given as follows:
myFunction[A\_, B\_] := Module[{n, A0, B0},
n = Length[A] + Length[B];
A0 = PadRight[A, n];
B0 = PadRight[B, n];
Tally@Table[Sort[DeleteCases[A0 + pB0, 0], Greater],
{pB0, Permutations@B0}]
];
Timing[
Table[
myFunction[A, B]
, {A, IntegerPartitions[8]}
, {B, IntegerPartitions[8]}]
]
I am looking for a solution which does this quickly, for say all integer partitions A, B of some maximal size n. A recursive solution with memoization would be ok (and perhaps preferred if this leads to greater speed).
The motivation for this question has to do with multiplication of monomial symmetric 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/205650/edit).
Closed 3 years ago.
[Improve this question](/posts/205650/edit)
## Challenge
You have a Chinese Checkers board looking like this:
```
board = [
[''],
['', ''],
['', '', ''],
['', '', '', '', '', '', ''],
['', '', '', '', '', ''],
['', '', '', '', ''],
['', '', '', '', '', ''],
['', '', '', '', '', '', ''],
['', '', ''],
['', ''],
['']
];
```
Your job is that, given two inputs `a` and `b` (pointing to `board[a][b]`), you must return all the indices of the adjacent squares.
## Example
Here are a couple examples:
```
0,0 => [1,0], [1,1]
1,0 => [0,0], [1,1], [2,0], [2,1]
3,6 => [3,5], [4,5]
5,2 => [4,2], [4,3], [5,1], [5,3], [6,2], [6,3]
```
## Rules
* You can assume that the input values `a` and `b` point to a valid position in the array
* You can take in `a` and `b` as separate parameters, or an array `[a,b]`
* The order of the output doesn't matter
* You should not return the position being inputted
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest code wins!
]
|
[Question]
[
**This question already has answers here**:
[Is a number divisible by each of its digits?](/questions/41902/is-a-number-divisible-by-each-of-its-digits)
(71 answers)
Closed 3 years ago.
# Task
Write a function or program that takes `n` as a parameter and prints the first `n` self-divisors.
# Definition of Self-divisor
A positive integer is called a “self-divisor” if every decimal digit of the number is a divisor of the number, that is, the number is evenly divisible by each and every one of its digits.
### Example
For example, the number 128 is a self-divisor because it is evenly divisible by 1, 2, and 8. However, 26 is not a self-divisor because it is not evenly divisible by the digit 6. Note that 0 is not considered to be a divisor of any number, so any number containing a 0 digit is NOT a self-divisor. There are infinitely many self-divisors.
# Scoring
This is code-golf, so the shortest answer in bytes wins
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 16 bytes
05AB1E probably has some sort of slice, but I failed to find it.
```
∞ʒDSÖß}ʒ0å_}ηs<è
```
[Try it online!](https://tio.run/##ASQA2/9vc2FiaWX//@KInsqSRFPDlsOffcqSMMOlX33Ot3M8w6j//zM "05AB1E – Try It Online")
# Explanation
```
∞ [1, 2, 3, ...]
ʒ Filter all that satisfies:
DS its DigitS
Ö is divisible
ß} ßy the original number.
ʒ Filter out ^ that satisfies:
0å_} 0 is å digit of the output.
ηs<è Trunctuatè by the input.
```
] |
[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/203879/edit).
Closed 3 years ago.
[Improve this question](/posts/203879/edit)
Let's say I have a `.env` file with the following contents:
```
CF_WORKERS_ACCOUNT_ID=abcdef34632114
CF_WORKERS_API_TOKEN=abcdef34632114def3463def3463
FAB_DEV_ZONE_ID=434932843272439874329
```
I'm doing a screencast, and I want to quickly `cat .env` to show what's in the file, without broadcasting the exact values, since they're secret.
What I want is a one-line unix command (I'm on OSX personally) that gives me:
```
> cat .env | some_command
CF_WORKERS_ACCOUNT_ID=••••••••••••••
CF_WORKERS_API_TOKEN=••••••••••••••••••••••••••••
FAB_DEV_ZONE_ID=•••••••••••••••••••••
```
A little thing, but would be neat!
My best attempt is `cat .env | ruby -pe 'k,v=$_.split("=");$_="#{k}=#{v.gsub(/./,"•")}"'` but I'm sure it can be shorter...
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 12 bytes
Uhh, I'd just solve it anyway...
```
'=¡`g'•иJ'=ý
```
[Try it online!](https://tio.run/##yy9OTMpM/X9u639120MLE9LVHzUsurDDS9328N7/tf@jlZzd4sP9g7xdg4LjHZ2d/UP9QuI9XWwTk5JTUtOMTcyMjQwNTZR0UJQFeMaH@Hu7@qGpgjKhFFCPm6NTvItrWHyUv58ryFATYxNLYyMLE2MjcyMTY0sLcyDLUikWAA "05AB1E – Try It Online")
## Explanation
```
'=¡ Split by equal signs
` Put both parts onto the stack
g Find the length of the second item
'•иJ Repeat that many •'s
'=ý Join by the equal sign
```
[Answer]
# vim, ~~14~~ ~~13~~ 12 keystrokes, assuming you can somehow type •
Somehow matches 05AB1E.
```
:%norm$vT=r•
```
Assumes there is only one `=` character in a line.
Overly generic explanation:
```
:%norm on every line do these normal mode commands
$ go to the end of string
vT= select until but not including the previous =
r• replace with a nice unicode dot
```
just type these commands and don't forget not to save
[Try it online! (with V)](https://tio.run/##K/v/30o1L78oV6UsxLboUcOi//@d3eLD/YO8XYOC4x2dnf1D/ULiPV1sE5OSU1LTjE3MjI0MDU24kBUFeMaH@Hu7@qGpgTKhFJebo1O8i2tYfJS/nyvIQBNjE0tjIwsTYyNzIxNjSwtzIMuSCwA "V (vim) – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/), 23 chars
```
1while s/(=.*)[^•]/$1•/
```
as in
```
cat .env | perl -ple'1while s/(=.*)[^•]/$1•/'
```
[Try it online!](https://tio.run/##K0gtyjH9/9@wPCMzJ1WhWF/DVk9LMzruUcOiWH0VQyCl//@/s1t8uH@Qt2tQcLyjs7N/qF9IvKeLbWJSckpqmrGJmbGRoaEJF7KiAM/4EH9vVz80NVAmlOJyc3SKd3ENi4/y93MFGWhibGJpbGRhYmxkbmRibGlhDmRZ/ssvKMnMzyv@r1uQAwA "Perl 5 – Try It Online")
[Answer]
# [sed](https://www.gnu.org/software/sed/) -E, 22 chars (26 bytes)
```
:a;s/(=.*)[^•]/\1•/;ta
```
[Try it online!](https://tio.run/##K05N0U3PK/3/3yrRulhfw1ZPSzM67lHDolj9GEMgpW9dkvj/v7NbfLh/kLdrUHC8o7Ozf6hfSLyni21iUnJKapqxiZmxkaGhCReyogDP@BB/b1c/NDVQJpTicnN0indxDYuP8vdzBRloYmxiaWxkYWJsZG5kYmxpYQ5kWf7LLyjJzM8r/q/rCgA "sed – Try It Online")
This replaces every character after the first `=` with a `•`.
Your use case would be:
`cat .env|sed -E ':a;s/(=.*)[^•]/\1•/;ta'`
or
`cat .env|sed ':a;s/\(=.*\)[^•]/\1•/;ta'`
(which is one byte shorter as a shell command).
By the way, you can shorten this again if you change your command structure slightly:
`sed ':a;s/\(=.*\)[^•]/\1•/;ta'<.env`
] |
[Question]
[
### Introduction:
Two resistors, `R1` and `R2`, in parallel (denoted `R1 || R2`) have a combined resistance `Rp` given as:
$$R\_{P\_2} = \frac{R\_1\cdot R\_2}{R\_1+R\_2}$$
or as suggested in comments:
$$R\_{P\_2} = \frac{1}{\frac{1}{R\_1} + \frac{1}{R\_2}}$$
Three resistors, `R1`, `R2` and `R3` in parallel (`R1 || R2 || R3`) have a combined resistance `(R1 || R2) || R3 = Rp || R3` :
$$R\_{P\_3} = \frac{\frac{R\_1\cdot R\_2}{R\_1+R\_2}\cdot R\_3}{\frac{R\_1\cdot R\_2}{R\_1+R\_2}+R\_3}$$
or, again as suggested in comments:
$$R\_{P\_3} = \frac{1}{\frac{1}{R\_1} + \frac{1}{R\_2}+ \frac{1}{R\_3}}$$
These formulas can of course be extended to an indefinite number of resistors.
---
### Challenge:
Take a list of positive resistor values as input, and output the combined resistance if they were placed in parallel in an electric circuit. You may not assume a maximum number of resistors (except that your computer can handle it of course).
### Test cases:
```
1, 1
0.5
1, 1, 1
0.3333333
4, 6, 3
1.3333333
20, 14, 18, 8, 2, 12
1.1295
10, 10, 20, 30, 40, 50, 60, 70, 80, 90
2.6117
```
---
**Shortest code in each language wins. Explanations are highly encouraged.**
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~5~~ 3 bytes
```
zOz
```
[Try it online!](https://tio.run/##yy9OTMpM/f@/yr/q//9oQwMdBRA2AmJjIDYBYlMgNgNicyC2AGJLg1gA "05AB1E – Try It Online")
---
### Explanation
```
z # compute 1/x for each x in input
O # sum input
z # compute 1/sum
```
[Answer]
# [Haskell](https://www.haskell.org/), ~~18~~ 16 bytes
```
(1/).sum.map(1/)
```
[Try it online!](https://tio.run/##y0gszk7NyfmfZhvzX8NQX1OvuDRXLzexAMT@n5uYmadgq1BQlJlXoqCikKYQbaKjYKajYBz7/19yWk5ievF/3QjngAAA "Haskell – Try It Online")
[Answer]
# [MATLAB](https://ch.mathworks.com/products/matlab.html), 14 bytes
In MATLAB `norm(...,p)` computes the `p`-norm of a vector. This is usually defined for \$p \geqslant 1\$ as
$$\Vert v \Vert\_p = \left( \sum\_i \vert v\_i \vert^p \right)^{\frac{1}{p}}.$$
But luckily for us, it also happens to work for \$p=-1\$. (Note that it does not work in Octave.)
```
@(x)norm(x,-1)
```
[Don't try it online!](https://tio.run/##y08uSSxL/f/fQaNCMy@/KFejQkfXUPN/Yl6xRrShjpGOcazmfwA "Octave – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~5~~ 3 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
İSİ
```
**[Try it online!](https://tio.run/##y0rNyan8///IhuAjG/7//x9taKCjAMJGQGwMxCZAbArEZkBsDsQWQGxpEAsA "Jelly – Try It Online")**
### How?
Initially I forgot this form from my electronic engineering days ...how easily we forget.
```
İSİ - Link: list of numbers, R e.g. [r1, r2, ..., rn]
İ - inverse (vectorises) [1/r1, 1/r2, ..., 1/rn]
S - sum 1/r1 + 1/r2 + ... + 1/rn
İ - inverse 1/(1/r1 + 1/r2 + ... + 1/rn)
```
[Answer]
# [Octave](https://www.gnu.org/software/octave/), 15 bytes
```
@(x)1/sum(1./x)
```
[Try it online!](https://tio.run/##y08uSSxL/Z@mYKugp6f330GjQtNQv7g0V8NQT79C83@aRrShgmGsJheIYaCjAMJGQGwMxCZAbArEZkBsDsQWQGxpEKv5HwA "Octave – Try It Online")
Harmonic mean, divided by `n`. Easy peasy.
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 22 bytes
```
$args|%{$y+=1/$_};1/$y
```
[Try it online!](https://tio.run/##RY3BDoJADETv@xUbUgXiJHYXxFVCwp@gB9ADiQYOSnC/fa0kag/NvGknc7892mG8tn0fqKvmQOfhMr5WM02bymyp8aXsKXil6KkrXSeJgUmhtMxH/iFHgewLlmFyGAcHC2N/AbEZcswYOWPHKBh7hmMcOE2lQ6qX14ia0zFa5Jo6XTdlHCsf3g "PowerShell – Try It Online")
Takes input via splatting and uses the same 1/sum of inverse trick as many of the others are doing
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 4 [bytes](https://github.com/abrudz/SBCS)
```
÷1⊥÷
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT/////B2w0ddSw9v/5/2qG3Co94@o0ddzY/6pgYHOQPJEA/PYC4gDZRKUzA0ACEjAwVjAwUTAwVTAwUzAwVzAwULAwVLg/8A "APL (Dyalog Unicode) – Try It Online")
-1 thanks to [Adám](https://codegolf.stackexchange.com/users/43319/ad%c3%a1m).
[Answer]
# [R](https://www.r-project.org/), 15 bytes
```
1/sum(1/scan())
```
[Try it online!](https://tio.run/##K/r/31C/uDRXA0gmJ@ZpaGr@NzTgAiIjAy5jAy4TAy5TAy4zAy5zAy4LAy5Lg/8A "R – Try It Online")
Follows the same Harmonic Mean principle seen in other answers.
[Answer]
# JavaScript, 28 bytes
```
a=>a.map(y=>x+=1/y,x=0)&&1/x
```
[Try it Online!](https://tio.run/##DcJRDoIwFATA25A2LLBVQfx4XMT48YJAIEgJGFJOX53MpIfu7Tau32zx7y72ElUazT@6mlOakIorTgShTRJXhNj6Zfdzl89@ML15OuL/QlyJG1ESFXEnauLBl7XxBw)
[Answer]
# [Perl 5](https://www.perl.org/) `-pa -MList::Util=reduce`, 26 bytes
```
$_=reduce{$a*$b/($a+$b)}@F
```
[Try it online!](https://tio.run/##K0gtyjH9/18l3rYoNaU0ObVaJVFLJUlfQyVRWyVJs9bB7f9/QwVDLiAGkiYKZgrGXEYGCoYmCoYWChYKRgqGRlyGQL6BAlDU2EDBxEDB1EDBzEDB3EDBwkDB0uBffkFJZn5e8X9dX5/M4hIrq9CSzByoXf91E3MKAA "Perl 5 – Try It Online")
[Answer]
# [Perl 6](http://perl6.org/), 14 bytes
```
1/*.sum o 1/**
```
[Try it online!](https://tio.run/##JcpBDoIwFIThq/whxAUx@l6ppUbpVQgLu5JgICwI8ey1wmq@zMznNb1dGlZOkTbptbrMy8BIVpUezP1KUXa0gS1Sdt@COE48FQ3nPQ5YHPUfRlCLejwGNfspV0IeasEKN8EJjeCFu4T0Aw "Perl 6 – Try It Online")
`1 / **` is an anonymous function that returns a list of the reciprocals of its arguments. `1 / *.sum` is another anonymous function that returns the reciprocal of the sum of the elements of its list argument. The `o` operator composes those two functions.
[Answer]
# bash + coreutils, 25 bytes
```
bc -l<<<"1/(0${@/#/+1/})"
```
[TIO](https://tio.run/##DYhBCsIwFAX3OcWjdqGI5P001kiz8B6li9YEKgQLVnBhPXvMYgZmpnGd82d@pIhXHAPStvU96oRh6BAWrPFdqsvTHafkva9E71l/b3qnj6J/hyqH5RmzQFSh2KJFowwhFuLgYCBGSWmi3IawxJloiQvhiCv/)
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 10 bytes
```
1/Tr[1/#]&
```
[Try it online!](https://tio.run/##JYoxDoMwFEN3roHE5Cr@IdAwFHEEBjbUIUJFZaBDlA3l7GmAyc/P3l34fnYXtsWl9ZVETX4WVb6rNPrtF@by0a9Drmo4ikMgEVfcYNCiPkETYiAWFhqir1NWRB5qwhAN0RJPwhIdYxHTHw "Wolfram Language (Mathematica) – Try It Online")
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf/blob/master/math_golf.txt), 3 [bytes](https://github.com/maxbergmark/mathgolf/blob/master/code_page.py)
```
∩Σ∩
```
The same as other answers, using the builtins `∩` (\$\frac{1}{n}\$) and `Σ` (sum):
$$M(x\_1,...,x\_n)=\frac{1}{\frac{1}{x\_1} + \frac{1}{x\_2} + ... + \frac{1}{x\_n}}$$
[Try it online.](https://tio.run/##y00syUjPz0n7//9Rx8pzi4HE///RhjqGsVwgEkyb6JjpGANpIwMdQxMdQwsdCx0jHUMjkAqgiIEOUNzYQMfEQMfUQMfMQMfcQMfCQMfSIBYA)
[Answer]
# Java 8, 24 bytes
```
a->1/a.map(d->1/d).sum()
```
I noticed there wasn't a Java answer yet, so figured I'd add one.
[Try it online.](https://tio.run/##hVDLTsMwELz3K1Y9Oep2sdNQgiqQkLjSS4@Ig0lclJA4UexUqlCvfACfyI@EzUOiFQculnd3ZnZ2cn3Qyzx975JCOwdPOrMfM4DMetPsdWJg25cAadW@FgYSkTOBWp8V5HxjdEmPw2Q3FKCDDcNPM36c1z5LYAsW7qDTy3t1panUtUj7bxqQa0sRdJseW7MEYyfKocpSKNmJYNXMvj2/sO5owxvnhUI1rPktLxsRrnF13gglqghVjDGGqMILMo8kMmAlMZJ4LXEt8UZiLPFW/jlmcDbwxjyIiKOqWz/Z2x2dNyVVraeanfvCnuX10DT66MhX41ViJC7m8P35BfOFpX/CpWo/cYLJ2Kn7AQ)
**Explanation:**
Uses the same Harmonic Mean approach as other answers:
$$M(x\_1,...,x\_n)=\frac{1}{\frac{1}{x\_1} + \frac{1}{x\_2} + ... + \frac{1}{x\_n}}$$
```
a-> // Method with DoubleStream parameter and double return-type
a.map(d->1/d) // Calculate 1/d for each value `d` in the input-stream
.sum() // Then take the sum of the mapped list
1/ // And return 1/sum as result
```
[Answer]
# [PHP](https://php.net/), 51 bytes
Reciprocal of sum of reciprocals. Input is `$a`.
```
1/array_reduce($a,function($c,$i){return$c+1/$i;});
```
[Try it online!](https://tio.run/##HcuxDsIgEADQX2G4ASJJQa2tQeOnGHLSwALkUgbT9Nvx7PDGV2Ptj1eNVYB/eiL/ldZo8XdmF3ZlI7uxic3sbpQTAWPpdjjWm8KnYZDg9dIyrqlkCaghqY3C2igDnuwAye3K9f4D "PHP – Try It Online")
[Answer]
# JavaScript (ES6), 29 bytes
```
a=>a.reduce((p,c)=>p*c/(p+c))
```
[Try it online!](https://tio.run/##lc@9DoIwEMDx3ae4sdVa2vI9wOhLGIemFIMhtAE0vn09ViFBL/0nnX65e@iXnszY@fk8uMaGtgq6qjUfbfM0lhDPDK1qfzQR8SdDaTBumFxvee/upCVXyUDC7twon92le9uGJJRCFIHg6WGD2te2qBjnW0sYZAzivzW5qSmBmyEpCwb4FP7Ub5pU5frSRcMWNcYSLMUyLMcKrBRrTfFMyjx8AA "JavaScript (Node.js) – Try It Online")
or:
```
a=>1/a.reduce((p,c)=>p+1/c,0)
```
[Try it online!](https://tio.run/##lc@9DoMgEMDxvU/BCCkFDr8HHfsSTQeC2GiMGLVN356eazWxvfBPmH6568zLzHZqx@Uy@NqFpgymrEAaMbn6aR2lI7esrMYzSMsVC9YPs@@d6P2DNvQGnAA5nDsTi7@2b1fTmDEiJVEiOe1Qx9oeFeF8azEnKSfR3xrsalrhZkhCzgk@jT/9mwa62F66atiqRliMJViKZViOFWqraZECZOED "JavaScript (Node.js) – Try It Online")
But with this approach, using `map()` (as [Shaggy did](https://codegolf.stackexchange.com/a/192651/58563)) is 1 byte shorter.
[Answer]
# [Python 3](https://docs.python.org/3/), 30 bytes
```
lambda r:1/sum(1/v for v in r)
```
**[Try it online!](https://tio.run/##TY7LCoMwEEX3fsXsTGBAY6y1gl9SXVhUKtQoMRX69emN0EfIYc7NzEDWl7svRvuxbvyjm299R7ZSyfachUp2GhdLO02GrPTB3bC5EEVEOFfFpFr@@V/MmQom/YlZih7eVMmEm8Gy72bogTCjQQ5OoABnUIJL2kayOuZXOxknwk@YxqNKpm1Y67gxMdNg@mBw6d8 "Python 3 – Try It Online")**
[Answer]
# [Perl 5](https://www.perl.org/) (-p), 17 bytes
```
$a+=1/$_}{$_=1/$a
```
[Try it online!](https://tio.run/##K0gtyjH9/18lUdvWUF8lvrZaJR7ESPz/39CAC4iMDLiMDbhMDLhMDbjMDLjMDbgsDLgsDf7lF5Rk5ucV/9ctAAA "Perl 5 – Try It Online")
[Answer]
# x86-64 Machine code - ~~20~~ 18 bytes
```
0F 57 C0 xorps xmm0,xmm0
loopHead
F3 0F 53 4C 8A FC rcpss xmm1,dword ptr [rdx+rcx*4-4]
0F 58 C1 addps xmm0,xmm1
E2 F6 loop loopHead
0F 53 C0 rcpps xmm0,xmm0
C3 ret
```
Input - Windows calling convention. First parameter is the number of resistors in `RCX`. A pointer to the resistors is in `RDX`. `*ps` instructions are used since they are one byte smaller. Technically, you can only have around 2^61 resistors but you will be out of RAM long before then. The precision isn't great either, since we are using `rcpps`.
[Answer]
# [MATL](https://github.com/lmendo/MATL), 5 bytes
```
,1w/s
```
[Try it online!](https://tio.run/##y00syfn/X8ewXL/4//9oIwMdBUMTILbQUQAiIyDLKBYA "MATL – Try It Online")
I'm not sure if "do twice" (`,`) counts as a loop, but this is just the harmonic mean, divided by `n`.
Alternately, `,-1^s` is five bytes as well.
[Answer]
# Intel 8087 FPU machine code, 19 bytes
```
D9 E8 FLD1 ; push 1 for top numerator on stack
D9 EE FLDZ ; push 0 for running sum
R_LOOP:
D9 E8 FLD1 ; push 1 numerator for resistor
DF 04 FILD WORD PTR[SI] ; push resistor value onto stack
DE F9 FDIV ; divide 1 / value
DE C1 FADD ; add to running sum
AD LODSW ; increment SI by 2 bytes
E2 F4 LOOP R_LOOP ; keep looping
DE F9 FDIV ; divide 1 / result
D9 1D FSTP WORD PTR[DI] ; store result as float in [DI]
```
This uses the stack-based floating point instructions in the original IBM PC's 8087 FPU.
Input is pointer to resistor values in `[SI]`, number of resistors in `CX`. Output is to a single precision (DD) value at `[DI]`.
[Answer]
# [Rattle](https://github.com/DRH001/Rattle), 24 bytes
```
|>II^[=1+#g`e_1P+~s]`e_1
```
[Try it Online!](https://www.drh001.com/rattle/?flags=&code=%7C%3EII%5E%5B%3D1%2B%23g%60e_1P%2B%7Es%5D%60e_1&inputs=10%2C%2010%2C%2020%2C%2030%2C%2040%2C%2050%2C%2060%2C%2070%2C%2080%2C%2090)
This answer can probably be golfed more (can anyone outgolf me in my own language?)
# Explanation
```
| take input, parse automatically (Rattle's input parsing is powerful
enough to recognise "1,2,3" etc. as a list)
> move pointer to the right (to slot 1)
I flatten input list and insert into consecutive memory slots
I^ get length of this list (which is still on top of the stack)
[ ... ]` loop structure: loop as many times as the length of the list
=1 set top of stack to 1
+# increment top of stack by list's iterator
(the number of times the loop has run)
g` get the value in storage at the calculated index (iterator + 1)
e_1 get 1/x of this value
P set the pointer to slot 0
+~ increment the current value by the stored value in slot 0
s save the result to slot 0
e_1 get 1/x of this value
```
[Answer]
# [Dart](https://www.dartlang.org/), 42 bytes
```
f(List<num>a)=>a.reduce((p,e)=>p*e/(p+e));
```
[Try it online!](https://tio.run/##ZYxBDsIgFET3noLlRyf6oVgxak/gDYwLYmnCooRUujKeHYk7a2Y1702md1MuZaBreOZznMfOyUvntpPv54cnSvC1p7XfUdp4KU9ldCGSfK2ESFOImQa6KQh1r@6X1SyhQYtmCTVDGSgLCw2l/46qZtRRwzCMPaNlHBiWceTv@F0@ "Dart – Try It Online")
Having to explicitly specify the `num` type is kinda sucky, prevents type infering, because it would infer to `(dynamic, dynamic) => dynamic` which can't yield doubles for some reason
[Answer]
# [PHP](https://php.net/), 40 bytes
```
for(;$n=$argv[++$i];$r+=1/$n);echo 1/$r;
```
[Try it online!](https://tio.run/##K8go@G9jXwAk0/KLNKxV8mxVEovSy6K1tVUyY61VirRtDfVV8jStU5Mz8hWAzCLr////GxqAkJHBf2OD/yYG/00N/psZ/Dc3@G9h8N/SAAA "PHP – Try It Online")
Tests: [Try it online!](https://tio.run/##VY/baoQwEIbv8xSDBDZiUKO77iGVvkNvrZSwpKvFjZJooZQ@u501le0O@WEO3/xDhmaYn56HZiCEjtqNDkqoCGBUgoOoOSQJpPHu3vrXzX342ZZDwSH3M/E4y1LcQkAcOODLMMtWUGTH1f1GoW50jtqidqgCtUcdUMfU72VxIcSe1JKQ995qdW6A/X1AOViyEL4XX6rs5RO/paxVX29XbS@aVWbqOnTyoFw4fW56CF60m7oR0BSqAGL46FvDNhw2K4y9oIbWnSCQM2JMUlMuN6ooom0tqY1KkVATysURUyvn@4FXG/h7k3F6ZLQNH0qL5c/8Cw "PHP – Try It Online")
Similar to [Yimin Rong's solution](https://codegolf.stackexchange.com/a/192652/81663) but without built-ins and all program bytes are included in the bytes count.
[Answer]
# Python 3, ~~58~~ 44 bytes
```
f=lambda x,y=0,*i:f(x*y/(x+y),*i)if y else x
```
A recursive function. Requires arguments to be passed unpacked, like so:
```
i=[10, 10, 20]
f(*i)
```
or
```
f(10, 10, 20)
```
**Explanation:**
```
# lambda function with three arguments. *i will take any unpacked arguments past x and y,
# so a call like f(10, 20) is also valid and i will be an empty tuple
# since y has a default value, f(10) is also valid
f=lambda x,y=0,*i: \
# a if case else b
# determine parallel resistance of x and y and use it as variable x
# since i is passed unpacked, the first item in the remaining list will be y and
# the rest of the items will be stored in i
# in the case where there were no items in the list, y will have the default value of 0
f(x*y/(x+y),*i) \
# if y does not exist or is zero, return x
if y else x
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 7 bytes
```
Ｉ∕¹Σ∕¹Ａ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMM5sbhEwyWzLDMlVcNQRyG4NBeJ55lXUFqioQkG1v//R0cbGegoGJoAsYWOAhAZAVlGsbH/dctyAA "Charcoal – Try It Online") Link is to verbose version of code. Works by calculating the current drawn by each resistor when 1V is applied, taking the total, and calculating the resistance that would draw that current when 1V is applied. Explanation:
```
Ａ Input array
∕¹ Reciprocal (vectorised)
Σ Sum
∕¹ Reciprocal
Ｉ Cast to string for implicit print
```
[Answer]
# [J](http://jsoftware.com/), 6 bytes
```
1%1#.%
```
[Try it online!](https://tio.run/##TYsxCoNAFER7T/GIiAR0mb@uugqpAqlS5QpBCWm8f7WaIirMg3kM800XV87cRkoqxLhRO@6v5yNZYbkr0jUjm96fhRnDTvWQQEfzFy8sYJGIx/x@0C/b2IggWtGJXkQxKK0 "J – Try It Online")
[Answer]
# [MATLAB], 15 bytes
One more byte than *flawr* excellent answer, but I had to use other functions so here goes:
```
@(x)1/sum(1./x)
```
It's rather explicit, it sums the inverse of the resistances, then invert the sum to output the equivalent parallel resistance.
[Answer]
# [Forth (gforth)](http://www.complang.tuwien.ac.at/forth/gforth/Docs-html/), 49 bytes
```
: f 0e 0 do dup i cells + @ s>f 1/f f+ loop 1/f ;
```
[Try it online!](https://tio.run/##hY9BTsMwEEX3PcVnxaJTGCdpmlIJISFxCcrCJA6JSOPKdoCevkxiEJVQVS9iR/7v/XFtXWgWb/W4HY93qMEGjMqiGvZoUZqu85jjAf6@hrqtUc/RWbufzhshvmI8DOX7Sf4qhionnw228I00lENAsPDBOoNKB422x87srDsQfNuXBk/jIOIzvr8OaPSHwevQdmEhSe2cPviZgsJeV0ikelxbPDqjg4n3@GxF8KxIvcxiSka@QelmExjRdELPgb9o@odmyOX3AppRTuk/NGGoDKpAIbOoZJLk5yUJk8pIFVRQQiqJuvzkEaJjiDRlZIwlI2esGAVjzZNcrs@/TuxM0pEyZUxLppxpxVQwrTl2Cf5TdvwG "Forth (gforth) – Try It Online")
Input is a memory address and array length (used as an impromptu array, since Forth doesn't have a built-in array construct)
Uses the sum-of-inverse method as most other answers are
### Code Explanation
```
: f \ start a new word definition
0e \ stick an accumulator on the floating point stack
0 do \ start a loop from 0 to array-length -1
dup \ copy the array address
i cells + \ get the address of the current array value
@ s>f \ get the value and convert it to a float
1/f f+ \ invert and add to accumulator
loop \ end the loop definition
1/f \ invert the resulting sum
; \ end the word definition
```
] |
[Question]
[
**Input:** You will be passed a string containing a single english word. All letters will be lowercase, and there will be no non-alphabetic characters in the string.
**Output:** You will return an integer from 1 to 7 representing how many syllables you think are in the word.
**Scoring:** Your program will be run against all of the words found on [this repository](https://github.com/nathanmerrill/wordsbysyllables). If you get `N` words correct, and your program is `M` bytes large, then your score is `N-(M*10)`. Largest score wins.
To generate my syllable count, I used [this](https://en.wiktionary.org/wiki/Wiktionary:Frequency_lists/PG/2006/04/1-10000) as my word list and [this](http://www.gutenberg.org/ebooks/3204) to count the syllables.
[Answer]
# Ruby, 8618 correct (91.1%), 53 bytes, 8618 - 10 \* 53 = 8088 score
```
->s{s.scan(/[aiouy]+e*|e(?!d$|ly).|[td]ed|le$/).size}
```
This is an anonymous Ruby function which uses regexes to count syllables.
The function adds a syllable for every instance of:
* A run of non-`e` vowels, followed by zero of more `e`s
* An `e` which is *not* part of a trailing `ed` or `ely`, with the exception of trailing `ted` or `ded`s
* A trailing `le`
## Analysis
The basic idea is to count runs of vowels, but this by itself isn't very accurate (`[aeiouy]+` gets 74% correct). The main reason for this is because of the [silent `e`](https://en.wikipedia.org/wiki/Silent_e), which modifies the previous vowel sound while not being pronounced itself. For example, the word `slate` has two vowels but only one syllable.
To deal with this, we take `e` out of the first part of the regex and treat it separately. Detecting silent `e`s is hard, but I found two cases where they occur often:
* As part of a trailing `ed` (unless it's a `ted` or `ded` like `settled` or `saddled`),
* As part of a trailing `evy` (e.g. `lovely`)
These cases are specifically excluded in what would otherwise be `e.`.
The reason for the `.` in `e(?!d$|ly).` is to consume the next char if there is a double vowel (e.g. `ea` or `ee`), and so that `e` at the end of the word are not counted. However a trailing `le` *is* usually pronounced, so that is added back in.
Finally, vowel runs are counted as one syllable. While this may not always be the case (e.g. `curious`), it's often difficult to work out whether there are multiple syllables. Take the `ia` of `celestial` and `spatial`, as an example.
## Test program
I don't really know Ruby so I'm not sure how well it can be golfed. I did manage to scrape together a test program by consulting a lot of SO though:
```
cases = 0
correct = 0
s = "->s{s.scan(/[aiouy]+e*|e(?!d$|ly).|[td]ed|le$/).size}"
f = eval s
for i in 1 ... 8
filepath = i.to_s + "-syllable-words.txt"
file = File.open(filepath)
while (line = file.gets)
word = line.strip
cases += 1
if f.call(word) == i
correct += 1
end
end
end
p "Correct: #{correct}/#{cases}, Length: #{s.length}, Score: #{correct - s.length*10}"
```
[Answer]
# Python3, 7935 - 10 \* 71 = 7225
My quick-and-dirty answer: count runs of consecutive vowels, but remove any final e's first.
```
lambda w:len(''.join(" x"[c in"aeiouy"]for c in w.rstrip('e')).split())
```
After stripping off the e's, this replaces vowels with `x` and all other characters with a space. The result is joined back into a string and then split on whitespace. Conveniently, whitespace at the beginning and end is ignored (e.g. `" x xx ".split()` gives `["x","xx"]`). The length of the resulting list is therefore the number of vowel groups.
The original, 83-byte answer below was more accurate because it only removed a single e at the end. The newer one thus has problems for words like `bee`; but the shortened code outweighs that effect.
```
lambda w:len(''.join(" x"[c in"aeiouy"]for c in(w[:-1]if'e'==w[-1]else w)).split())
```
Test program:
```
syll = lambda w:len(''.join(c if c in"aeiouy"else' 'for c in w.rstrip('e')).split())
overallCorrect = overallTotal = 0
for i in range(1, 7):
with open("%s-syllable-words.txt" % i) as f:
words = f.read().split()
correct = sum(syll(word) == i for word in words)
total = len(words)
print("%s: %s correct out of %s (%.2f%%)" % (i, correct, total, 100*correct/total))
overallCorrect += correct
overallTotal += total
print()
print("%s correct out of %s (%.2f%%)" % (overallCorrect, overallTotal, 100*overallCorrect/overallTotal))
```
Evidently this was too dirty and not quick enough to beat Sp3000's Ruby answer. ;^)
[Answer]
# Perl, 8145 - 3 \* 30 = 7845
Using the lists from before the recent commits.
```
#!perl -lp
$_=s/(?!e[ds]?$)[aeiouy]+//g
```
[Answer]
# Python, 5370-10\*19 = 5180
This program simply assumes that longer words means more syllables.
```
lambda x:len(x)/6+1
```
The tester program I use is:
```
correct = 0
y = lambda x:len(x)/6+1
for i in xrange(1,8):
f = file(str(i)+"-syllable-words.txt")
lines = f.read().split("\n")
f.close()
correct += len([1 for line in lines if y(line)==i])
print correct
```
] |
[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/189281/edit).
Closed 4 years ago.
[Improve this question](/posts/189281/edit)
*(Inspired by the [first problem solved](http://web.stanford.edu/class/archive/cs/cs166/cs166.1146/lectures/00/Small00.pdf) in Stanford’s advanced data structures course.)*
Despite the academicese-heavy name, the [problem](https://en.wikipedia.org/wiki/Range_minimum_query) we're going to solve is almost unbearably simple.
We have a list of numbers.
```
[31, 41, 59, 26, 53, 58, 97]
```
We're going to cut some contiguous snippet out of that list of numbers.
```
[31, 41, 59, 26, 53, 58, 97]
|41, 59, 26, 53|
```
And then we're going to find the minimum of that snippet. In this case, that's quite obviously 26. That's all.
And the obvious solution is pretty fast, too, with \$O(n)\$ time and \$O(1)\$ space in the size of the list:
```
minval = arbitrarily large value
for (i=first snippet index, i<last snippet index, i++)
if (list[i]<minval) minval = list[i]
```
### So what's with the [fastest-algorithm](/questions/tagged/fastest-algorithm "show questions tagged 'fastest-algorithm'")?
Where it gets interesting is when you try to see how efficient you can make it when you have a fixed list but a large number of range minimum queries -- snippets to find the minimum of. This version of the problem is useful, for example, if you have a huge time series you want to load only once, but you want to find the minimum of many different subintervals of that time series.
In such a scenario, it would actually be faster in practice to literally precompute all \$n^2/2\$ queries, store it in a table, and then just retrieve data from that table for an \$O(1)\$ time and \$O(n^2)\$ space solution.
[](https://i.stack.imgur.com/6C3Ks.png)
*^dynamic programming solution taken from the Stanford slides*
And then if you're clever enough, you realize that you only have to store each query with size that's a power of two -- you can just combine those power-of-two minima to sum to an arbitrarily sized query, and achieve the same results with constant time and linearithmic rather than quadratic space.
Interestingly, if you keep optimizing, you can get to an \$O(1)\$ time and \$O(n)\$ space solution using a sort of augmented list known as a Fischer-Heun structure. I'd love to go into the details of the structure here, but explaining how it weaves into Cartesian tree building on fixed-size snippets would make this question about 50 pages long. It's explained in the [Wikipedia page](https://en.wikipedia.org/wiki/Range_minimum_query), however, along with several faster-than-linear intermediate structures.
(If you can get past a research paywall, [here's](https://epubs.siam.org/doi/pdf/10.1137/090779759) the original Fischer & Heun 2011 paper. And if you’d prefer the much more verbose but much more hand-holdy Stanford lecture style, [here](http://web.stanford.edu/class/cs166/lectures/01/Small01.pdf) are the follow-up slides that goes into this solution, including lots of intermediates.)
---
## The challenge
You can either write a full program or a function that calculates the result of a series of range minimum queries given a fixed list. Scoring is set up such that in general, the shortest and most-efficient-over-lots-of-queries code wins.
**Input:**
A list of integers `xs`, followed by a series of `i, j` pairs denoting the start and end of the snippet, inclusive (so the 26 example above uses indices i=1 and j=4). The list of integers is guaranteed to have at least one integer, and `0 <= i <= j < len(xs)`. This can be taken in any format that works best for your language — for example, one list for `xs` and one list of tuples for the `i, j` pairs; or maybe all the different pairs as a variable number of arguments. For a full program that takes in input from stdin, I’ll fix a format for the input:
```
xs[0] xs[1] xs[2] xs[3] ...
i1 j1
i2 j2
i3 j3
...
```
**Output:**
An ordered collection of the range minima for each `i, j` query, in the same order that they were given. In case an unordered map (such as a Python dictionary) from each `i, j` query to its range minimum works better for your language, that will also be allowed as an output; as long as it's obvious which minimum is related to which query.
Once again, for a full program that prints to stdout or a file, I’ll fix the format to have each range minimum on each newline (trailing newlines permitted).
## Scoring:
Lower score is better; score is determined by
```
at(b)^2+as(b)
```
Where `b` is the byte count of your code, `at` is the asymptotic runtime `Ө(n)` of the algorithm in the size of `xs` interpreted as a function of `n`, and `as` is the asymptotic space usage \$\Theta(n)\$ in the size of `xs` interpreted as a function of \$n\$. (All constant coefficients in such \$\Theta(n)\$ expressions must be 1, and only the fastest growing term may be kept in expressions, as is standard.)
Therefore, the above pseudocode solution, which uses \$\Theta(n)\$ time and \$\Theta(1)\$ space, and is 126 characters, would have a score of `(b => b**2 + 1)(126)=15876+1=15877`. (Of course, the pseudocode isn't really valid since it's missing a construct to deal with multiple queries, and also because it's uncompilable pseudocode...)
## Test cases:
**Input:**
```
31 41 59 26 53 58 97
1 4
0 2
5 6
```
**Output:**
```
26
31
58
```
**Input:**
```
1
0 0
0 0
```
**Output:**
```
1
1
```
**Input:**
```
-4 28 31 -54
0 0
0 1
0 2
0 3
1 1
1 2
1 3
2 2
2 3
3 3
```
**Output:**
```
-4
-4
-4
-4
28
28
-54
31
-54
-54
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 6 bytes, \$O(n)\$ runtime, \$O(1)\$ space, score 37
```
r/ịṂɗ€
```
[Try it online!](https://tio.run/##y0rNyan8/79I/@Hu7oc7m05Of9S05v///9FGOmaxOtGGOsZA0kzHPPZ/tLGhjomhjqmljpGZjqmxjqmFjqV5LAA "Jelly – Try It Online")
I hope I’ve understood the scoring correctly. Naive implementation that simply indexes into the list and finds the minimum. Requires no lookup table, but limited by needing to check each input value (so \$O(n)\$ in efficiency.
[Answer]
# Python 2, 42 bytes, \$O(n)\$ runtime, \$O(1)\$ space, score 1765
```
lambda x,L:[min(x[l[0]:l[1]+1])for l in L]
```
[Answer]
# T-SQL 2008, 55 bytes
I apologize for being unable to figure out the scoring system.
Input is 2 tables
```
SELECT min(x)FROM a,b
WHERE i>f and i<t+2GROUP BY z,f,t
```
**[Try it online](https://rextester.com/BMHK24405)**
] |
[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/188566/edit).
Closed 4 years ago.
[Improve this question](/posts/188566/edit)
Like Brainfuck or JSFuck would be efficient in terms of *number* of characters needed, but what languages would have the highest amount of information per character?
I was thinking of APL and J but there has to be more.
My goal with this question is to find a program that would allow a person with theoretically infinite amounts of computational power output through their fingers a program in the least amount of time possible.
]
|
[Question]
[
In this challenge you will write a program that takes two newline-separated strings, s1 (the first line) and s2 (the second line), as input (STDIN or closest). You can assume that the length of s1 will always be smaller than 30 and bigger than the length of s2. The program should then output each step in the levenshtein distance from s1 to s2.
To clarify what each step in the levenshtein distance means, the program will print n strings, where n is the levenshtein distance between s1 and s2, and the levenshtein distance between two adjacent strings will always be one. The order doesn't matter. The output should be newline-separated and not include s1, only the in-betweens and s2. The program should also run in under one minute on a modern computer.
Examples:
Input:
```
Programming
Codegolf
```
Output:
```
rogramming
Cogramming
Coramming
Coamming
Codmming
Codeming
Codeging
Codegong
Codegolg
Codegolf
```
Input:
```
Questions
Answers
```
Output:
```
uestions
Aestions
Anstions
Ansions
Answons
Answens
Answers
```
Input:
```
Offline
Online
```
Output:
```
Ofline
Online
```
Input:
```
Saturday
Sunday
```
Output:
```
Sturday
Surday
Sunday
```
[Here](http://ideone.com/w5zhpz) is a link to a python script that prints out the distance and the steps.
Additional rules:
* No use of the internet
* [Standard loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) apply
This is code-golf so keep you code short; shortest code wins!
[Answer]
# Haskell, ~~201~~ 194 bytes
```
l=length
g[]n u=map(\_->"")n
g(b:c)[]u=(u++c):g c[]u
g(b:c)n@(o:p)u|b==o=g c p(u++[o])|1<2=((u++o:c):g c p(u++[o]))!((u++c):g c n u)
a!b|l a<l b=a|1<2=b
p[a,n]=g a n""
f=interact$unlines.p.lines
```
Longer than expected. Maybe I can golf it down a little bit ...
Usage example:
```
*Main> f -- call via f
Questions -- User input
Answers -- no newline after second line!
uestions -- Output starts here
Aestions
Anstions
Ansions
Answons
Answens
Answers
```
It's a brute force that decides between changing and deleting if the initial characters differ.
[Answer]
# [APL (Dyalog 18.0)](https://www.dyalog.com/), 66 bytes
```
{⍺<Ö≢⍵:⍺∇⎕←0~⍨0@(⊃(⍸~p)~⍳⊃⌽⍸p←⍵=⍺↑⍨≢⍵)⊢⍵⋄j←⊃⍸⍺≠⍵⋄⍺≢⍵:⍺∇⎕←⍺[j]@j⊢⍵}
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT/9/eNqjtgnVGo96twKRwqPeXZpADEQIka2atf@rgSI2QKWdi4B8K5CKjvZHfVOBWg3qHvWuMHDQeNTVDNSyo65AEyiwGch71LMXyC8AKgFqsQVpaZsIVAoxQvNRF4h61N2SBVIAVN27A6SkcwFEFMzGsAvIjs6KdciCaK79nwYW6wNrX/Ood8uh9cYgS/qmBgc5A8kQD8/g/@qOTs4urm7qCmkKUGaEOhfEOHV1LjTZCBAbSdY5PyU1PT8nDSwfUJSfXpSYm5uZl45iQl5xeWpRMVhJYGlqcUlmfl6xOgA "APL (Dyalog Unicode) – Try It Online")
Works correctly now.
A recursive function submission, done with a lot of input from Adám and Bubbler.
Input is taken as `<s2> f <s1>`.
## Explanation
`⍺<⍥≢⍵:` if the strings have different lengths:
`0@(...)⊢⍵` put a zero at the following index:
`⊃` first element of:
`(⍸~p)` characters which do not match
`~` without
`⍳⊃⌽⍸p←⍵=⍺↑⍨≢⍵` all indices before last character match
`0~⍨` remove the zero(thereby removing the element)
`⍺∇⎕←` display the result and recurse
`⋄⍺≢⍵:` Otherwise, till the strings match:
`i←⊃⍸⍺≠⍵` find first non-matching element
`⍺[i]@i⊢⍵` and replace the element at that index
`⍺∇⎕←` display the result, and recurse
] |
[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/186527/edit).
Closed 4 years ago.
[Improve this question](/posts/186527/edit)
I suspect Gomoku may be one of the simplest games to implement in code. <https://en.wikipedia.org/wiki/Gomoku> The game is this: players BLACK and WHITE take turns putting down black and white stones. Black traditionally goes first. If, when a player puts down their stone, they now have 5 in a row of their color, they win. That's it.
A simple way to implement this is to just keep two lists of (x, y) integer coordinates, one for black stones and one for white stones. Players simply specify an integer x,y coordinate, any x,y coordinate at all! The game checks if there is already a stone there of either color, and if not x,y is added to the list, and then the game checks if that stone made them have 5 in a row now.
Notice I have said nothing about board size, or checking if a move is on the board or not. My thought is that specifying board size and determining what to do at edges actually complicates things more! Gomoku *can* be played on an infinite board, and the game still works actually!
Anyway, to be clear, I believe the specifications are, implement Gomoku on a board of size between or including 15x15 and infinity x infinity (I actually suspect inifinite may be simpler.) Let the user know who's turn it is to play, by alternately printing "b>","w>". If an invalid entry is made, such as playing where there already is a stone there, just keep asking the user who played the invalid move until they play a valid move. To keep things extra short, no need to print the board state, actually! But if on a user's turn, they have completed 5 in a row orthogonaly or diagonally, print, or throw an error, that can simply say "w" or "b", to say who won. Shortest code that does the specified, wins.
If you want to print the board state or make things look nicer or make an AI or whatever, no need to do that, but you can add with or separately to your submission if you feel like it.
I wrote a non-golfed but still shortish implementation in Python, with simple board printing and stuff before. Here it is: <https://github.com/jeffkaufman/game-complexity/blob/master/gomoku.py>
And here's my entire attempt at a golfed version with the basic IO and move checking, but without board printing. I am quite sure this is *not* optimal at all, I'm not often a golfer. All I mostly did was make variables one character / remove whitespace and stuff, you guys can \*easily\* do better, I know.
```
w,b=[],[]
def o((x,y),s,(v,u)):
if (x,y) in s:return o((x+v,y+u),s,(v,u))
if v:return x
return y
d=((0,1),(1,0),(1,1),(-1,1))
def W(m,s):
for (x,y) in d:
if o(m,s,(x,y))-o(m,s,(-x,-y))>5:return 1
return 0
def t(c,p):
while 1:
C=raw_input(c+'>')
try:
x,y=C.split()
m=(int(x),int(y))
except ValueError:continue
if m in b+w:continue
p.append(m)
if W(m,p):raise Exception(c)
break
while 1:t("b",b),t("w",w)
```
an example run from that, which throws a Python error saying who won, at the end:
```
b>0 0
w>-4 5
b>0 1
w>0 1
w>7 12
b>0 2
w>7 12
w>4 5
b>0 -1
w>4 4
b>0 3
Traceback (most recent call last):
File "C:/Users/udqbp/OneDrive/Desktop/test.py", line 22, in <module>
while 1:t("b",b),t("w",w)
File "C:/Users/udqbp/OneDrive/Desktop/test.py", line 20, in t
if W(m,p):raise Exception(c)
Exception: b
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 54 bytes
```
Ḋ,Z,ŒD$ŒrFs2ḢƇ<5Ȧ
0x⁹s⁴-;N1¦Ṅ©+Ɠœị®Ḋ¤$¿ṪṬṭ0x$Ʋ¹NƭƊƊ$Ç¿
```
[Try it online!](https://tio.run/##y0rNyan8///hji6dKJ2jk1xUjk4qcis2erhj0bF2G9MTy7gMKh417ix@1LhF19rP8NCyhztbDq3UPjb56OSHu7sPrQPqO7RE5dD@hztXPdy55uHOtQYVKsc2Hdrpd2ztsa5jXSqH2w/t/39oEdA4HfdjXZH/jXWMuCDYkMtExxiIDblMdUyA2JDLTMcUiA25zHXMAA "Jelly – Try It Online")
A full program that reads input on stdin. For each loop through it prints the current player (1 or -1) and the 16x16 grid. Moves are input on stdin as a Python array (e.g. `[3,2]`) with or without the surrounding square brackets. The only validation done is to make sure that the relevant cell is empty. When there are 5 (or more) in a row, the program ends and prints out the winner and final grid.
If checking for a valid move can be omitted, 10 bytes can be saved:
# [Jelly](https://github.com/DennisMitchell/jelly), 44 bytes
```
Ḋ,Z,ŒD$ŒrFs2ḢƇ<5Ȧ
0x⁹s⁴-;N1¦Ṅ+ƓṪṬṭ0x$¹Nƭ¤ƲÇ¿
```
[Try it online!](https://tio.run/##y0rNyan8///hji6dKJ2jk1xUjk4qcis2erhj0bF2G9MTy7gMKh417ix@1LhF19rP8NCyhztbtI9Nfrhz1cOdax7uXGtQoXJop9@xtYeWHNt0uP3Q/v@HFgG16rgf64r8b6xjxGWsY8hlomMMxIZcpjomQGzIZaZjCsSGXOY6ZgA "Jelly – Try It Online")
Conversely, if the w/b designation in the spec is strict, that costs 15 bytes:
# [Jelly](https://github.com/DennisMitchell/jelly), 69 bytes
```
ị“wb ”Ḣ
Ḋ,Z,ŒD$ŒrFs2ḢƇ<5Ȧ
0x⁹s⁴-;N1¦Ñ;”>ṄṛƲ©+Ɠœị®Ḋ¤$¿ṪṬṭ0x$Ʋ¹NƭƊƊ$Ç¿Ñ
```
[Try it online!](https://tio.run/##y0rNyan8///h7u5HDXPKkxQeNcx9uGMR18MdXTpROkcnuagcnVTkVmwEFDvWbmN6YhmXQcWjxp3Fjxq36Fr7GR5adniiNVCL3cOdLQ93zj626dBK7WOTj04GGndoHdCMQ0tUDu1/uHPVw51rHu5ca1ChAlSx0@/Y2mNdx7pUDrcf2n944v//xjpGXBBsyGWiYwzEhlymOiZAbMhlpmMKxIZc5jpmAA "Jelly – 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/179677/edit).
Closed 5 years ago.
[Improve this question](/posts/179677/edit)
Pretty simple challenge here. Who can make the fastest algorithm (lowest time complexity) to determine whether or not the circle is "boxed in" given the following setup?
**Input**: Your program receives a pair of numbers `(a,b)` that denotes the position of a circle on a grid like this with arbitrary dimensions:
[](https://i.stack.imgur.com/DZLdB.png)
Where `a-1` is the number of units from the right, and `b-1` is the number of units from the bottom. Assume that `(a,b)` is always a white square. The program should work for arbitrary arrangements of purple squares .
**Definition of "boxed in"**: A circle at `S=(a,b)` is "boxed in" if there is no path from `S` consisting of vertical, horizontal, and diagonal one space moves that reaches a white square on the edge of the grid without going on a purple space. This means that:
[](https://i.stack.imgur.com/LZDPx.png)
is boxed in, but:
[](https://i.stack.imgur.com/TKLmp.png)
is not because of the open diagonal.
**Output**: A Boolean - is in boxed in, or not?
You can choose whatever data structure you want to represent the grid. Remember though, the goal is speed so keep that in mind.
[please note this is my first post on this SE site, so if I need to fix something let me know]
]
|
[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/175190/edit).
Closed 5 years ago.
[Improve this question](/posts/175190/edit)
Calculate the maximum number of circles of radius `r` that can fit in a rectangle with width `x` and height `y`. Write a function that take `r`, `x` and `y` as input and returns the number of circles that fit in the rectangle.
[](https://i.stack.imgur.com/CYv2M.png)
]
|
[Question]
[
Write a program that outputs the lyrics to 99 Bottles of Beer, **in as few bytes as possible**.
Lyrics:
```
99 bottles of beer on the wall, 99 bottles of beer.
Take one down and pass it around, 98 bottles of beer on the wall.
98 bottles of beer on the wall, 98 bottles of beer.
Take one down and pass it around, 97 bottles of beer on the wall.
97 bottles of beer on the wall, 97 bottles of beer.
Take one down and pass it around, 96 bottles of beer on the wall.
96 bottles of beer on the wall, 96 bottles of beer.
Take one down and pass it around, 95 bottles of beer on the wall.
95 bottles of beer on the wall, 95 bottles of beer.
Take one down and pass it around, 94 bottles of beer on the wall.
....
3 bottles of beer on the wall, 3 bottles of beer.
Take one down and pass it around, 2 bottles of beer on the wall.
2 bottles of beer on the wall, 2 bottles of beer.
Take one down and pass it around, 1 bottle of beer on the wall.
1 bottle of beer on the wall, 1 bottle of beer.
Go to the store and buy some more, 99 bottles of beer on the wall.
```
Rules:
* Your program must log to STDOUT or an acceptable alternative, or be returned from a function (with or without a trailing newline).
* Your program must be a full, runnable program or function.
* Languages specifically written to submit a 0-byte answer to this challenge are allowed, just not particularly interesting.
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.
* **This is different from the output by HQ9+ or 99. Any answers written in these languages will be deleted.**
As this is a catalog challenge, this is not about finding the language with the shortest solution for this (there are some where the empty program does the trick) - this is about finding the shortest solution in every language. Therefore, no answer will be marked as accepted.
### 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:
```
## [><>](http://esolangs.org/wiki/Fish), 121 bytes
```
```
<style>body { text-align: left !important} #answer-list { padding: 10px; width: 290px; float: left; } #language-list { padding: 10px; width: 290px; float: left; } table thead { font-weight: bold; } table td { padding: 5px; }</style><script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="language-list"> <h2>Shortest Solution by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr> </thead> <tbody id="languages"> </tbody> </table> </div> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr> </thead> <tbody id="answers"> </tbody> </table> </div> <table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table><script>var QUESTION_ID = 64198; var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe"; var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk"; var OVERRIDE_USER = 36670; var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page; function answersUrl(index) { return "//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 "//api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER; } function getAnswers() { jQuery.ajax({ url: answersUrl(answer_page++), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { answers.push.apply(answers, data.items); answers_hash = []; answer_ids = []; data.items.forEach(function(a) { a.comments = []; var id = +a.share_link.match(/\d+/); answer_ids.push(id); answers_hash[id] = a; }); if (!data.has_more) more_answers = false; comment_page = 1; getComments(); } }); } function getComments() { jQuery.ajax({ url: commentUrl(comment_page++, answer_ids), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { data.items.forEach(function(c) { if (c.owner.user_id === OVERRIDE_USER) answers_hash[c.post_id].comments.push(c); }); if (data.has_more) getComments(); else if (more_answers) getAnswers(); else process(); } }); } getAnswers(); var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/; var OVERRIDE_REG = /^Override\s*header:\s*/i; function getAuthorName(a) { return a.owner.display_name; } function process() { var valid = []; answers.forEach(function(a) { var body = a.body; a.comments.forEach(function(c) { if(OVERRIDE_REG.test(c.body)) body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>'; }); var match = body.match(SCORE_REG); if (match) valid.push({ user: getAuthorName(a), size: +match[2], language: match[1], link: a.share_link, }); else console.log(body); }); valid.sort(function (a, b) { var aB = a.size, bB = b.size; return aB - bB }); var languages = {}; var place = 1; var lastSize = null; var lastPlace = 1; valid.forEach(function (a) { if (a.size != lastSize) lastPlace = place; lastSize = a.size; ++place; var answer = jQuery("#answer-template").html(); answer = answer.replace("{{PLACE}}", lastPlace + ".") .replace("{{NAME}}", a.user) .replace("{{LANGUAGE}}", a.language) .replace("{{SIZE}}", a.size) .replace("{{LINK}}", a.link); answer = jQuery(answer); jQuery("#answers").append(answer); var lang = a.language; lang = jQuery('<a>'+lang+'</a>').text(); languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang.toLowerCase(42), user: a.user, size: a.size, link: a.link}; }); var langs = []; for (var lang in languages) if (languages.hasOwnProperty(lang)) langs.push(languages[lang]); langs.sort(function (a, b) { if (a.lang_raw > b.lang_raw) return 1; if (a.lang_raw < b.lang_raw) return -1; return 0; }); for (var i = 0; i < langs.length; ++i) { var language = jQuery("#language-template").html(); var lang = langs[i]; language = language.replace("{{LANGUAGE}}", lang.lang) .replace("{{NAME}}", lang.user) .replace("{{SIZE}}", lang.size) .replace("{{LINK}}", lang.link); language = jQuery(language); jQuery("#languages").append(language); } }</script>
```
[Answer]
## C#, ~~285~~ ~~298~~ 289 Bytes
(My first attempt at Code golfing ...)
```
class d{static void Main(){for(int b=99;b>0;)System.Console.Write("{0}{6}{1}{2}, {0}{6}{1} of beer. {3}, {4}{6}{5}{2}.{7}",b,b==1?"":"s"," of beer on the wall",b==1?"Go to the store and buy some more":"Take one down and pass it around",b==1?99:b-1,b==2?"":"s"," bottle",b--<2?"":"\n\n");}}
```
A little bit ungolfed:
```
class d{
static void Main(){
for(int b = 99; b > 0;){
System.Console.Write("{0}{6}{1}{2}, {0}{6}{1} of beer.\n{3}, {4}{6}{5}{2}.{7}", b, b==1 ? "" : "s", " of beer on the wall", b == 1 ? "Go to the store and buy some more" : "Take one down and pass it around", b == 1 ? 99 : b-1, b== 2 ? "" : "s", " bottle", b--<2 ? "" : "\n\n");
}
}
}
```
[Answer]
# [Motorola MC14500B Machine Code](https://en.wikipedia.org/wiki/Motorola_MC14500B), 46612 bytes
For length reasons, I can not post the program here. However, it can be found [here in hexadecimal](https://dl.dropboxusercontent.com/s/c41qf1weyf6idda/mc14500b-hex-99bottles), and [here in binary](https://dl.dropboxusercontent.com/s/h57z170sjkduq0y/mc14500b-binary-99bottles) (padded with `0`s).
---
This is the shortest possible program in Motorola MC14500B machine code. It consists of only `1000` and `1001` (`8` and `9`, respectively); one opcode for each bit of output.
It uses 93,224 half-byte opcodes, and outputs the song lyrics one bit at a time. This is the only possible output method.
For those interested, the output goes to pin #3 (of 16), the I/O pin.
---
### Explanation
```
8 Store the register's value
9 Store the logical complement of the register's value
```
The register starts at `0`.
---
### Code Trivia
* The [hexadecimal](https://dl.dropboxusercontent.com/s/c41qf1weyf6idda/mc14500b-hex-99bottles) is 93,224 `8`s and `9`s long.
* The [binary](https://dl.dropboxusercontent.com/s/h57z170sjkduq0y/mc14500b-binary-99bottles) is 745,792 `1`s and `0`s long.
* I used the Python 2 code below to generate the code. Input `0` for binary and `1` for hexadecimal.
```
a,b=["8","9"]if input()else["00001000","00001001"]
f="""99 Bottles of Beer lyrics"""
print''.join(b if int(i)else a for i in''.join((8-len(bin(i)[2:]))*'0'+bin(i)[2:]for i in bytearray(f)))
```
[Answer]
# Vitsy, 0 Bytes
Seriously ain't got nothin' on me. (@Mego I'm so sorry. ;))
[Try it online!](http://vitsy.tryitonline.net) (Just hit "Run")
[Answer]
# [Seriously](https://github.com/Mego/Seriously), 1 byte
```
N
```
If the stack is empty (which it is at the start), `N` pushes the lyrics. Then they're implicitly printed at EOF.
Thanks to @Mego for fixing the Seriously interpreter.
[Answer]
## JavaScript ES6, ~~230~~ ~~218~~ ~~198~~ ~~196~~ ~~192~~ ~~188~~ 185 bytes
```
for(x=99,z=(a=' on the wall')=>`${x||99} bottle${1-x?'s':''} of beer`+a;x;)alert(z()+', '+z`.
`+(--x?'Take one down and pass it around, ':'Go to the store and buy some more, ')+z()+'.')
```
Just just trimming off a few bytes while still keeping it looking clean and understandable.
3 most recent revisions:
```
for(x=99,z=a=>`${x||99} bottle${1-x?'s':''} of beer${a||' on the wall'}`;x;)alert(z()+', '+z(`.
`)+(--x?'Take one down and pass it around, ':'Go to the store and buy some more, ')+z()+'.')
for(x=99,z=a=>(x||99)+' bottle'+(1-x?'s':'')+' of beer',w=' on the wall';x;)alert(z()+w+', '+z()+(--x?`.
Take one down and pass it around, `:`.
Go to the store and buy some more, `)+z()+w+'.')
for(x=99,o=' bottle',q=b=o+'s',e=' of beer',w=e+" on the wall";x;)alert(x+b+w+', '+x+b+e+(--x?`.
Take one down and pass it around, `+x:`.
Go to the store and buy some more, 99`)+(b=1-x?q:o)+w+'.')
```
[Answer]
# JavaScript ES6, ~~328~~ ~~318~~ ~~307~~ 305 bytes
Is an anonymous function. Add `f=` at the beginning to make function and `f()` to execute.
```
x=>eval('s=o=>v=(o?o:" no more")+" bottle"+(1==o?"":"s");for(o="",i=99;i>0;)o+=`${s(i)}@ on the wall, ${v}@.\nTake one down, pass it around, ${s(--i)}@ on the wall.\n`;o+`No more bottles@ on the wall, no more bottles@.\nGo to the store and buy some more, 99 bottles@ on the wall.`'.replace(/@/g," of beer"))
```
[Answer]
# C, ~~197~~ 196 bytes
```
main(i){for(i=299;i--/3;printf("%d bottle%s of beer%s%s",i/3?:99,"s"+5/i%2,i%3?" on the wall":i^3?".\nTake one down and pass it around":".\nGo to the store and buy some more",~i%3?", ":".\n\n"));}
```
I think I have reached the limit of this approach.
[Answer]
## Java ~~304~~ ~~301~~ ~~300~~ 295 Bytes
First time posting an answer. I heard we could use enum but could not find how.
```
interface A{static void main(String[]a){String b=" of beer",c=" on the wall",n=".\n",s;for(int i=100;i-->1;s=" bottle"+(i>1?"s":""),System.out.println(i+s+b+c+", "+i+s+b+n+(i<2?"Go to the store and buy some more, 99":"Take one down and pass it around, "+(i-1))+" bottle"+(i!=2?"s":"")+b+c+n));}}
```
## Ungolfed
```
interface A {
static void main(String[] a) {
String b = " of beer", c = " on the wall", n = ".\n", s;
for (int i = 100; i-- > 1; s = " bottle" + (i > 1 ? "s" : ""), System.out.println(i + s + b + c + ", " + i + s + b + n + (i < 2 ? "Go to the store and buy some more, 99" : "Take one down and pass it around, " + (i - 1)) + " bottle" + (i != 2 ? "s" : "") + b + c + n));
}
}
```
---
Thanks to `quartata`, `J Atkin` and `Benjamin Urquhart`
[Answer]
# [Templates Considered Harmful](https://github.com/feresum/tmp-lang), 667 bytes
```
Ap<Fun<Ap<Fun<Cat<Cat<Cat<Cat<Ap<A<1,1>,A<1>>,A<2,1>>,St<44,32>>,Ap<A<1,1>,A<1>>>,If<A<1>,Cat<Cat<Cat<Cat<St<46,10,84,97,107,101,32,111,110,101,32,100,111,119,110,32,97,110,100,32,112,97,115,115,32,105,116,32,97,114,111,117,110,100,44,32>,Ap<A<1,1>,Sub<A<1>,T>>>,A<2,1>>,St<46,10,10>>,Ap<A<0>,Sub<A<1>,T>>>,Cat<Cat<Cat<St<46,10,71,111,32,116,111,32,116,104,101,32,115,116,111,114,101,32,97,110,100,32,98,117,121,32,115,111,109,101,32,109,111,114,101,44,32>,Ap<A<1,1>,I<98>>>,A<2,1>>,St<46>>>>>,I<98>>>,Fun<Cat<Cat<Cat<Add<A<1>,T>,St<32,98,111,116,116,108,101>>,If<A<1>,St<'s'>,St<>>>,St<32,111,102,32,98,101,101,114>>>,St<32,111,110,32,116,104,101,32,119,97,108,108>>
```
Sort of expanded:
```
Ap<
Fun<
Ap<
Fun<
Cat<
Cat<Cat<Cat< Ap<A<1,1>,A<1>> , A<2,1> >, St<44,32> >, Ap<A<1,1>,A<1>> >,
If<A<1>,
Cat<Cat<Cat<Cat< St<46,10,84,97,107,101,32,111,110,101,32,100,111,119,110,32,97,110,100,32,112,97,115,115,32,105,116,32,97,114,111,117,110,100,44,32> , Ap<A<1,1>,Sub<A<1>,T>> >, A<2,1> >, St<46,10,10> >, Ap<A<0>,Sub<A<1>,T>> >,
Cat<Cat<Cat< St<46,10,71,111,32,116,111,32,116,104,101,32,115,116,111,114,101,32,97,110,100,32,98,117,121,32,115,111,109,101,32,109,111,114,101,44,32> , Ap<A<1,1>,I<98>> >, A<2,1> >, St<46> >
>
>
>,
I<98>
>
>,
Fun< Cat<Cat<Cat< Add<A<1>,T> , St<32,98,111,116,116,108,101> >, If<A<1>,St<'s'>,St<>> >, St<32,111,102,32,98,101,101,114> > >,
St<32,111,110,32,116,104,101,32,119,97,108,108>
>
```
[Answer]
# [///](http://esolangs.org/wiki////), 341 bytes
```
/-/\/\///+/ bottle-)/\/&\/<\/
-(/\/\/?\/ ->/+s of beer-^/> on the wall-!/^,-$/>.
-@/$Take one down and pass it around,-#/^.
-*/?1@?0#<0!?0@-%/99!?9@?8#<8!?8@?7#<7!?7@?6#<6!?6@?5#<5!?5@?4#<4!?4@?3#<3!?3@?2#<2!?2@?1#<1!-&/?9#
%*-</
9(9/%*/</
8(8)7(7)6(6)5(5)4(4)3(3)2(2)1(1)0(0-
0/
- 0/ /#/1+s/1+/
% 01$Go to the store and buy some more, 099^.
```
It would need 99 years to write a proper explanation of this code.
I would probably just include the result of every stage...
Basically, this compresses the lyrics repeatedly (as is every answer in [///](http://esolangs.org/wiki////)).
[Try it online!](http://slashes.tryitonline.net/#code=Ly0vXC9cLy8vKy8gYm90dGxlLSkvXC8mXC88XC8KLSgvXC9cLz9cLyAtPi8rcyBvZiBiZWVyLV4vPiBvbiB0aGUgd2FsbC0hL14sLSQvPi4KLUAvJFRha2Ugb25lIGRvd24gYW5kIHBhc3MgaXQgYXJvdW5kLC0jL14uCi0qLz8xQD8wIzwwIT8wQC0lLzk5IT85QD84Izw4IT84QD83Izw3IT83QD82Izw2IT82QD81Izw1IT81QD80Izw0IT80QD8zIzwzIT8zQD8yIzwyIT8yQD8xIzwxIS0mLz85IwolKi08Lwo5KDkvJSovPC8KOCg4KTcoNyk2KDYpNSg1KTQoNCkzKDMpMigyKTEoMSkwKDAtCjAvCi0gMC8gLyMvMStzLzErLwolIDAxJEdvIHRvIHRoZSBzdG9yZSBhbmQgYnV5IHNvbWUgbW9yZSwgMDk5Xi4&input=)
### Each step of decompression
Since replacements followed by replacements will have the string `//`, it will appear often.
It appears often enough that I decided to compress `//` into `-`.
When this is decompressed, the result is as follows:
```
/+/ bottle//)/\/&\/<\/
//(/\/\/?\/ //>/+s of beer//^/> on the wall//!/^,//$/>.
//@/$Take one down and pass it around,//#/^.
//*/?1@?0#<0!?0@//%/99!?9@?8#<8!?8@?7#<7!?7@?6#<6!?6@?5#<5!?5@?4#<4!?4@?3#<3!?3@?2#<2!?2@?1#<1!//&/?9#
%*//</
9(9/%*/</
8(8)7(7)6(6)5(5)4(4)3(3)2(2)1(1)0(0//
0/
// 0/ /#/1+s/1+/
% 01$Go to the store and buy some more, 099^.
```
The string `bottle` only appeared three times, but I compressed it to `+` anyways:
```
/)/\/&\/<\/
//(/\/\/?\/ //>/ bottles of beer//^/> on the wall//!/^,//$/>.
//@/$Take one down and pass it around,//#/^.
//*/?1@?0#<0!?0@//%/99!?9@?8#<8!?8@?7#<7!?7@?6#<6!?6@?5#<5!?5@?4#<4!?4@?3#<3!?3@?2#<2!?2@?1#<1!//&/?9#
%*//</
9(9/%*/</
8(8)7(7)6(6)5(5)4(4)3(3)2(2)1(1)0(0//
0/
// 0/ /#/1 bottles/1 bottle/
% 01$Go to the store and buy some more, 099^.
```
Then, `)` corresponds to `/&/</` followed by a newline, and `(` corresponds to `//?/` , which are patterns that will be often used later:
```
/>/ bottles of beer//^/> on the wall//!/^,//$/>.
//@/$Take one down and pass it around,//#/^.
//*/?1@?0#<0!?0@//%/99!?9@?8#<8!?8@?7#<7!?7@?6#<6!?6@?5#<5!?5@?4#<4!?4@?3#<3!?3@?2#<2!?2@?1#<1!//&/?9#
%*//</
9//?/ 9/%*/</
8//?/ 8/&/</
7//?/ 7/&/</
6//?/ 6/&/</
5//?/ 5/&/</
4//?/ 4/&/</
3//?/ 3/&/</
2//?/ 2/&/</
1//?/ 1/&/</
0//?/ 0//
0/
// 0/ /#/1 bottles/1 bottle/
% 01$Go to the store and buy some more, 099^.
```
Now, we would decompress some useful strings:
* `>` decompresses to `bottles of beer`
* `^` decompresses to `bottles of beer on the wall`
* `!` decompresses to `^,`, where `^` is the one above.
* `$` decompresses to `>.\n`, where `>` is the first rule and `\n` is a newline.
* `@` decompresses to `$` followed by `Take one down and pass it around,`, where `$` is the rule above.
The decompressed code now becomes:
```
/*/?1 bottles of beer.
Take one down and pass it around,?0 bottles of beer on the wall.
<0 bottles of beer on the wall,?0 bottles of beer.
Take one down and pass it around,//%/99 bottles of beer on the wall,?9 bottles of beer.
Take one down and pass it around,?8 bottles of beer on the wall.
<8 bottles of beer on the wall,?8 bottles of beer.
Take one down and pass it around,?7 bottles of beer on the wall.
<7 bottles of beer on the wall,?7 bottles of beer.
Take one down and pass it around,?6 bottles of beer on the wall.
<6 bottles of beer on the wall,?6 bottles of beer.
Take one down and pass it around,?5 bottles of beer on the wall.
<5 bottles of beer on the wall,?5 bottles of beer.
Take one down and pass it around,?4 bottles of beer on the wall.
<4 bottles of beer on the wall,?4 bottles of beer.
Take one down and pass it around,?3 bottles of beer on the wall.
<3 bottles of beer on the wall,?3 bottles of beer.
Take one down and pass it around,?2 bottles of beer on the wall.
<2 bottles of beer on the wall,?2 bottles of beer.
Take one down and pass it around,?1 bottles of beer on the wall.
<1 bottles of beer on the wall,//&/?9 bottles of beer on the wall.
%*//</
9//?/ 9/%*/</
8//?/ 8/&/</
7//?/ 7/&/</
6//?/ 6/&/</
5//?/ 5/&/</
4//?/ 4/&/</
3//?/ 3/&/</
2//?/ 2/&/</
1//?/ 1/&/</
0//?/ 0//
0/
// 0/ / bottles of beer on the wall.
/1 bottles/1 bottle/
% 01 bottles of beer.
Go to the store and buy some more, 099 bottles of beer on the wall.
```
[Answer]
## Haskell, ~~228~~ 223 bytes
```
o=" of beer on the wall"
a n=shows n" bottle"++['s'|n>1]
b 1="Go to the store and buy some more, "++a 99
b n="Take one down and pass it around, "++a(n-1)
f=[99,98..1]>>= \n->[a n,o,", ",a n," of beer.\n",b n,o,".\n\n"]>>=id
```
Function `f` returns a string with the lyrics.
[Answer]
# Brainfuck, 743 bytes
```
++++++++++>>--->++++>------>-->>++>+>>+>->++[[>+++++++[>++>+>+<<<-]<-]+<+++]>>>>>--
>>-->>++>->+++[<]>[-<<+[<->-----]<---[<[<]>[->]<]+<[>-]>[-<++++++++++<->>>]-[<->---
--]<+++[<[<]>[+>]<]<->>>[>[[>]<<<<.<<<<---.>>>-.<<<++++.<.>>>.-.<<.<.>-.>>+.<+++.>-
.<<<.>---.>>.<<+++.<.>>>++.<<---.>----..<<.>>>>--.+++<<+.<<.>.>--.>-.<+++.->-.+<<++
+.<<.>.<<<<-<]>[[>]<<<-.<<<.<<<.>>.>.<<< . > > .<++++.---.<.>>-.+.>.<--.<.<.>----.>
>-.<<+++.<.>--.>+++.++++.<<.>>------.>+.--.<<+++.<.>>>.++.<-.++<.-<<.>.<<<<-<<<++++
+++++.>>>]<+>]<++[<<[<]>[.>]>>>>>>.>--.>>.<..->>.<<<+++.<<<<-[>>>>>.[<]]<[>]>+>>>.>
>>.<<+.<.>----.+++..->-.++[<<]<-[>>>>>.>>>.-.+<<<.>>.<++++.---.<.>>+++.---<----.+++
>>>..[<<]]<<[>]>-[>>>>++.--<.<<<+[>>>.<<<<]>[>]<-<]>>[>>.>.<<<<]>[<<++>]<[>]<-]>+>]
```
[Try it online!](https://tio.run/##bVJbagRBCDxQoycQLyJ@JIFACOQjsOefVJXu4yPN7oyPKi3tef99@/r5vH18X9d5nEwzS1mmg1fCT2QQglWVi62Jn4iwxu8Egp08JC1R1So6yyJg2BQGwaxiEtkBdqUJ9VQDcGbbC0m1RDokCVAJTQ0V4XwA55RAh0U86Dp9mkwixsRgPIfhgg@a7ynEtk7qjOVUFUcBJlWDNCj0sxWYkxLqHGnTSd1ysuoofexAFwWYkhfbeeZYXfRpnnuXvSNE3exVv9Og2HB7kRPP3RKFdfKPjc5KPef2djKwHHPlLnJq1ACAb1xY87tIddRWVjXRsxHW7gdr7uH8O/3acS9ArJON9bHR1BBIizw1XYPKMQaXDWO3yyBVp1Ti44TQvq4/ "brainfuck – Try It Online")
The above uses wrapping cells in a few places to save instructions. I've also made a non-wrapping version in [755 instructions](https://github.com/primo-ppcg/bfal/blob/master/samples/bottles.bf).
---
**Uncompressed**
The following is a polyglot in [Brainfuck Annotation Language](https://github.com/primo-ppcg/bfal).
```
; byte sequence
; \n _ _ _ _ c \n comma space d t o l T G
++++++++++>>
--->++++>------>-->>++>+>>+>->++
[[>+++++++[>++>+>+<<<-]<-]+<+++]
>>>>>-->>-->>++>->+++[<]
c = 0
n = 100
>
while(n)
[
n = n minus 1
-<<
N = str(n)
; first time \n _ becomes 9 9
+[<->-----]<---[<[<]>[->]<]
+<[>-]>[-<++++++++++<->>>]
-[<->-----]<+++[<[<]>[+>]<]
<->>>
if(c)
[
>
if(n)
[
'Take one down and'
[>]<<<<.<<<<---.>>>-.<<<++++.<.>>>.-.<<.<.>-.>>+.<+++.>-.<<<.>---.>>.<<+++.
' pass it around' comma space
<.>>>++.<<---.>----..<<.>>>>--.+++<<+.<<.>.>--.>-.<+++.->-.+<<+++.<<.>.<<<<-<
]>
else
[
'Go to the store and'
[>]<<<-.<<<.<<<.>>.>.<<<.>>.<++++.---.<.>>-.+.>.<--.<.<.>----.>>-.<<+++.
' buy some more' comma space
<.>--.>+++.++++.<<.>>------.>+.--.<<+++.<.>>>.++.<-.++<.-<<.>.<<<<-
N = '9'
N
<<<+++++++++.>>>
]
<+>
]
c = c plus 2
<++
while(c)
[
N
<<[<]>[.>]>>>
' bottle'
>>>.>--.>>.<..->>.<<<+++.<<<<
if(n minus 1) 's'
-[>>>>>.[<]]<[>]>+
' of beer'
>>>.>>>.<<+.<.>----.+++..->-.++
[<<]<-
if(c minus 1)
[
' on the wall'
>>>>>.>>>.-.+<<<.>>.<++++.---.<.>>+++.---<----.+++>>>..[<<]
]
<<[>]>-
if(c minus 2)
[
period newline
>>>>++.--<.<<<+
if(c minus 1) newline
[>>>.<<<<]>[>]<-<
]>>
else
[
comma space
>>.>.<<<<
]
if(not n) c = c minus 2
>[<<++>]
c = c minus 1
<[>]<-
]
c = 1
>+>
]
```
[Answer]
# Vim, 139 bytes
*Saved 6 bytes due to [xsot](https://codegolf.stackexchange.com/posts/comments/179296?noredirect=1)*.
```
i, 99 bottles of beer on the wall.<ESC>YIGo to t<SO> store and buy some more<ESC>qa
3P2xgJX$12.+<CAN>YITake one down a<SO> pass it around<ESC>o<ESC>q98@adk?s
xn.n.ZZ
```
This is my first attempt at golfing Vim commands, although apparently it's [quite popular](http://www.vimgolf.com/). I've included the final `ZZ` in the byte count (write to file and exit) as it seems to be the accepted norm.
Side note: [mission accomplished](http://golf.shinh.org/p.rb?99+shinichiroes+of+hamaji#ranking).
---
**Explanation**
```
Command Effect
-------------------------------------------------------------------------------------------
i, 99 bottles of beer on the wall.<ESC> insert text at cursor
Y copy this line into buffer
IGo to t<SO> store and buy some more<ESC> insert text at beginning of line
auto-complete "the" (<Ctrl-N>, searches forward)
qa begin recording macro into "a"
<LF> move down one line (if present)
3P paste 3 times before cursor
2x delete 2 characters at cursor
gJ join this line with next (without space between)
X delete character before cursor
$ move to last non-whitespace character of line
12. repeat the last edit command (X) 12 times
+ move to column 0 of next line
<CAN> numeric decrement (<Ctrl-X>)
Y copy this line into buffer
ITake one down a<SO> pass it around<ESC> insert text at beginning of line
auto-complete "and" (<Ctrl-N>, searches forward)
o<ESC> insert text on new line
q stop recording macro
98@a repeat macro "a" 98 times
dk delete upwards (this line and the one above it)
?s<LF> move to previous /s/
x delete character at cursor
n.n. repeat last match and delete 2 times
ZZ write to file and exit
```
[Answer]
## Python 2, 195
```
i=198
while i:s=`i/2or 99`+' bottle%s of beer'%'s'[1<i<4:];print['%s, '+s+'.','Take one down and pass it around, %s.\n',"Go to the store and buy some more, %s."][i%2+1/i]%(s+' on the wall');i-=1
```
Took the `i/2` idea from [Sp3000's answer](https://codegolf.stackexchange.com/a/64227/20260).
[Answer]
## JavaScript ES6, 237 217 208 203 195 193 189 186 bytes
It is getting pretty hard to golf this...
**Edit 1:** Somebody totally outgolfed me, looks like I have to try harder if I want to have the best Javascript answer.
**Edit 2:** I honestly can't believe that I managed to golf it that much!
```
for(i=99,Y=" on the wall",o=k=>k+(i||99)+` bottle${i==1?'':'s'} of beer`;i;)alert(o``+Y+o`, `+o(--i?`.
Take one down and pass it around, `:`.
Go to the store and buy some more, `)+Y+`.`)
```
Did I mess up somewhere?
I also apologize for using `alert`, if you want to test my code, replace it with `console.log`.
Currently, there is one other notable Javascript answer: ["99 Bottles of Beer"](https://codegolf.stackexchange.com/questions/64198/99-bottles-of-beer/64235#64235). Check it out! :D
[Answer]
# JavaScript ES6, ~~210~~ ~~209~~ ~~205~~ ~~199~~ ~~198~~ 196 bytes
```
s=""
for(i=299;--i>1;s+=`${i/3|0||99} bottle${5/i^1?"s":""} of beer`+(i%3?" on the wall":i^3?`.
Take one down and pass it around`:`.
Go to the store and buy some more`)+(~i%3?", ":`.
`));alert(s)
```
This is a crude translation of my C submission. I don't actually know javascript so there is definitely room for improvement.
Edit: Neat, I discovered backticks
[Answer]
# Brainfuck, 4028 bytes
This is quite hideous.
Lots of duplication, and very inefficient, so it won't win any prizes. However, I started it, and was determined to finish it.
I may try and improve this, but probably wont, because frankly, my brain is fucked.
## Golfed
```
>>+++[-<+++<+++>>]>>++++++[-<++++++++++<++++++++++>>]<---<--->>>+++++[-<++++++>]
<++>>++++++++++[-<++++++++++>]<-->>++++++++++[-<+++++++++++>]<+>>++++++++++[-<++
++++++++>]<+>>++++++++++[-<++++++++++>]<++>>++++++++++[-<+++++++++++>]<++++++>>+
+++++++++[-<++++++++++>]<++++>>++++++++++[-<+++++++++++>]<-->>++++++++++[-<+++++
++++++>]<++++>>++++++++++[-<+++++++++++>]<+++++>>++++++++++[-<+++++++++++>]>++++
++++++[-<+++++++++++>]<+++++++++>>++++++++++[-<++++++++++>]<--->>+++++[-<++++++>
]<++>>++++[-<++++++++++++>]<---->>++++[-<++++++++++++>]<-->++++++++++>>+++++++++
+[-<+++++++++++>]<--->>++++++++++[-<++++++++++>]>++++++++++[-<+++++++++++>]<++>>
++++++++++[-<++++++++++>]<+++++>>++++++++++[-<+++++++++++>]<+++++++<<<<<<<<<<<<<
<<<<<<<<<<<<[>[->.>.>.>.>.>>>..>>.<<<<.>>>>>>.<<<<<<<<<.>>.>>.<<<<.>.>>..>>>>>.<
<<<<<<<.>>.>>>>>>>>.>>>.<<<<<<<<.>.<<<.<<<.>>>>>>>>>>>.>.<<<<<..>>>>>>>.<.<<<<<<
<<<<<<<<<.>.->.>.>.>>>..>>.<<<<.>>>>>>.<<<<<<<<<.>>.>>.<<<<.>.>>..>>>>>.>>>>>>>.
>.<<<<<<<<<<<.>>>>>>>.>>>>>.<<<<<<<<<<<<<<.<<<.>>.>>>>>>>>.<<<<<<<.<<<.>>>>>>>>>
>>>>>>>>>.<<<<<<<<<<<<<<<<.>>>>>>>>>.<.>>>.<.<<.>>>>>>>>.<<<<<.>>>>>>.<<<<<<<.<<
<..>>>>.>>>>>>>.<<<<<<<<<<<<<<<.>>>>>>>>.<.<<<<.<<<<<<.>>>>>>>>>>>>>>>>>>>.<<<<<
<<<<<<.>>>>>>>>.<<<<.<.<<<<<<<<<<<<<<<.>.>.>.>.>>>..>>.<<<<.>>>>>>.<<<<<<<<<.>>.
>>.<<<<.>.>>..>>>>>.<<<<<<<<.>>.>>>>>>>>.>>>.<<<<<<<<.>.<<<.<<<.>>>>>>>>>>>.>.<<
<<<..>>>>>>>>.>..<<<<<<<<<<<<<<<<<<<]<->+++++++++>.>.>.>.>.>>>..>>.<<<<.>>>>>>.<
<<<<<<<<.>>.>>.<<<<.>.>>..>>>>>.<<<<<<<<.>>.>>>>>>>>.>>>.<<<<<<<<.>.<<<.<<<.>>>>
>>>>>>>.>.<<<<<..>>>>>>>.<.<<<<<<<<<<<<<<<.->.+++++++++>.>.>.>>>..>>.<<<<.>>>>>>
.<<<<<<<<<.>>.>>.<<<<.>.>>..>>>>>.>>>>>>>.>.<<<<<<<<<<<.>>>>>>>.>>>>>.<<<<<<<<<<
<<<<.<<<.>>.>>>>>>>>.<<<<<<<.<<<.>>>>>>>>>>>>>>>>>>.<<<<<<<<<<<<<<<<.>>>>>>>>>.<
.>>>.<.<<.>>>>>>>>.<<<<<.>>>>>>.<<<<<<<.<<<..>>>>.>>>>>>>.<<<<<<<<<<<<<<<.>>>>>>
>>.<.<<<<.<<<<<<.>>>>>>>>>>>>>>>>>>>.<<<<<<<<<<<.>>>>>>>>.<<<<.<.<<<<<<<<<<<<<<<
.>.>.>.>.>>>..>>.<<<<.>>>>>>.<<<<<<<<<.>>.>>.<<<<.>.>>..>>>>>.<<<<<<<<.>>.>>>>>>
>>.>>>.<<<<<<<<.>.<<<.<<<.>>>>>>>>>>>.>.<<<<<..>>>>>>>>.>..<<<<<<<<<<<<<<<<<<<<]
>--[->>.>.>.>.>>>..>>.<<<<.>>>>>>.<<<<<<<<<.>>.>>.<<<<.>.>>..>>>>>.<<<<<<<<.>>.>
>>>>>>>.>>>.<<<<<<<<.>.<<<.<<<.>>>>>>>>>>>.>.<<<<<..>>>>>>>.<.<<<<<<<<<<<<<<.->.
>.>.>>>..>>.<<<<.>>>>>>.<<<<<<<<<.>>.>>.<<<<.>.>>..>>>>>.>>>>>>>.>.<<<<<<<<<<<.>
>>>>>>.>>>>>.<<<<<<<<<<<<<<.<<<.>>.>>>>>>>>.<<<<<<<.<<<.>>>>>>>>>>>>>>>>>>.<<<<<
<<<<<<<<<<<.>>>>>>>>>.<.>>>.<.<<.>>>>>>>>.<<<<<.>>>>>>.<<<<<<<.<<<..>>>>.>>>>>>>
.<<<<<<<<<<<<<<<.>>>>>>>>.<.<<<<.<<<<<<.>>>>>>>>>>>>>>>>>>>.<<<<<<<<<<<.>>>>>>>>
.<<<<.<.<<<<<<<<<<<<<<.>.>.>.>>>..>>.<<<<.>>>>>>.<<<<<<<<<.>>.>>.<<<<.>.>>..>>>>
>.<<<<<<<<.>>.>>>>>>>>.>>>.<<<<<<<<.>.<<<.<<<.>>>>>>>>>>>.>.<<<<<..>>>>>>>>.>..<
<<<<<<<<<<<<<<<<<<]>>.>.>.>.>>>..>>.<<<<.>>>>>>.<<<<<<<<<.>>.>>.<<<<.>.>>..>>>>>
.<<<<<<<<.>>.>>>>>>>>.>>>.<<<<<<<<.>.<<<.<<<.>>>>>>>>>>>.>.<<<<<..>>>>>>>.<.<<<<
<<<<<<<<<<.->.>.>.>>>..>>.<<<<.>>>>>>.<<<<<<<<<.>>.>>.<<<<.>.>>..>>>>>.>>>>>>>.>
.<<<<<<<<<<<.>>>>>>>.>>>>>.<<<<<<<<<<<<<<.<<<.>>.>>>>>>>>.<<<<<<<.<<<.>>>>>>>>>>
>>>>>>>>.<<<<<<<<<<<<<<<<.>>>>>>>>>.<.>>>.<.<<.>>>>>>>>.<<<<<.>>>>>>.<<<<<<<.<<<
..>>>>.>>>>>>>.<<<<<<<<<<<<<<<.>>>>>>>>.<.<<<<.<<<<<<.>>>>>>>>>>>>>>>>>>>.<<<<<<
<<<<<.>>>>>>>>.<<<<.<.<<<<<<<<<<<<<<.>.>.>.>>>..>>.<<<<.<<<.>>.>>.<<<<.>.>>..>>>
>>.<<<<<<<<.>>.>>>>>>>>.>>>.<<<<<<<<.>.<<<.<<<.>>>>>>>>>>>.>.<<<<<..>>>>>>>>.>..
<<<<<<<<<<<<<<<<<.>.>.>.>>>..>>.<<<<.<<<.>>.>>.<<<<.>.>>..>>>>>.<<<<<<<<.>>.>>>>
>>>>.>>>.<<<<<<<<.>.<<<.<<<.>>>>>>>>>>>.>.<<<<<..>>>>>>>.<.<<<<<<<<<<<<<<.++++++
++>.>.>.>>>..>>.<<<<.<<<.>>.>>.<<<<.>.>>..>>>>>.>>>>>>>.>.>---->>+++++++++>++++<
<<.<<<<<<<<<<<<<<<.<<.>>>>>.<<<.<<.>>>>>.>.<<<.<<<.>>>>>>>>>.<<<<.<<<.>>>>>>.<<<
<<.<<<.>>>>>>>>>>>>.<<.>>>>>>>>.<<<<<.<<<<<<<<<<<<.>>>>>>>>>>>>>>>>>>>>.<<.<<<<<
<.<<<<.<<<<<<<.>>>>>>>>>>>>>>>>>>.<<<<<<<<<<<<<<<<<.>>>>>>>>>>.>>>>>>>.<<<<<<<<<
<<<<<<<<<.>>>>>>.<<<<<.>>>>>>>>>>>.<.<<<<<<<<<<<<<<..>.>.>.>>>..>>.<<<<.>>>>>>.<
<<<<<<<<.>>.>>.<<<<.>.>>..>>>>>.<<<<<<<<.>>.>>>>>>>>.>>>.<<<<<<<<.>.<<<.<<<.>>>>
>>>>>>>.>.<<<<<..>>>>>>>>.>.
```
## Ungolfed
```
# SETUP COUNTERS
>>+++[-<+++<+++>>]
>>++++++[-<++++++++++<++++++++++>>]<---<--->>
# SETUP CONSTANTS
>+++++[-<++++++>]<++>
>++++++++++[-<++++++++++>]<--> # B
>++++++++++[-<+++++++++++>]<+> # O
>++++++++++[-<++++++++++>]<+> # E
>++++++++++[-<++++++++++>]<++> # F
>++++++++++[-<+++++++++++>]<++++++> # T
>++++++++++[-<++++++++++>]<++++> # H
>++++++++++[-<+++++++++++>]<--> # L
>++++++++++[-<+++++++++++>]<++++> # R
>++++++++++[-<+++++++++++>]<+++++> # S
>++++++++++[-<+++++++++++>] # N
>++++++++++[-<+++++++++++>]<+++++++++># W
>++++++++++[-<++++++++++>]<---> # A
>+++++[-<++++++>]<++> # SPACE
>++++[-<++++++++++++>]<----> # Comma
>++++[-<++++++++++++>]<--> # Stop
++++++++++> # Newline
>++++++++++[-<+++++++++++>]<---> # K
>++++++++++[-<++++++++++>] # D
>++++++++++[-<+++++++++++>]<++> # P
>++++++++++[-<++++++++++>]<+++++> # I
>++++++++++[-<+++++++++++>]<+++++++ # U
# BACK TO START
<<<<<<<<<<<<<<<<<<<<<<<<<
[>
[
-> # Dec x0 counter
.> # Print 0x char
.> # Print x0 char
.>
.>.>>>..>>.<<<<.>>>>>>. # Bottles
<<<<<<<<<.
>>.>>. # Of
<<<<.
>.>>..>>>>>. # Beer
<<<<<<<<.
>>.>>>>>>>>. # On
>>>.
<<<<<<<<.>.<<<. # The
<<<.
>>>>>>>>>>>.>.<<<<<.. # Wall
>>>>>>>. # Comma
<.
<<<<<<<<<<<<<<<.>.- # Counter with decrement
>.
>.>.>>>..>>.<<<<.>>>>>>. # Bottles
<<<<<<<<<.
>>.>>. # Of
<<<<.
>.>>..>>>>>. # Beer
>>>>>>>. # Stop
>. # Newline
<<<<<<<<<<<.>>>>>>>.>>>>>.<<<<<<<<<<<<<<. # Take
<<<.
>>.>>>>>>>>.<<<<<<<. # One
<<<.
>>>>>>>>>>>>>>>>>>.<<<<<<<<<<<<<<<<.>>>>>>>>>.<. # Down
>>>.
<.<<.>>>>>>>>. # And
<<<<<.
>>>>>>.<<<<<<<.<<<.. # Pass
>>>>.
>>>>>>>.<<<<<<<<<<<<<<<. # It
>>>>>>>>.
<.<<<<.<<<<<<.>>>>>>>>>>>>>>>>>>>.<<<<<<<<<<<.>>>>>>>>. # Around
<<<<. # Comma
<.
<<<<<<<<<<<<<<<.>. # 0x and x0
>.
>.>.>>>..>>.<<<<.>>>>>>. # Bottles
<<<<<<<<<.
>>.>>. # Of
<<<<.
>.>>..>>>>>. # Beer
<<<<<<<<.
>>.>>>>>>>>. # On
>>>.
<<<<<<<<.>.<<<. # The
<<<.
>>>>>>>>>>>.>.<<<<<.. # Wall
>>>>>>>>. # Stop
>.. # Newline x2
<<<<<<<<<<<<<<<<<<< # Reset loop
]
<-
>+++++++++
>.>.
>.
>.>.>>>..>>.<<<<.>>>>>>. # Bottles
<<<<<<<<<.
>>.>>. # Of
<<<<.
>.>>..>>>>>. # Beer
<<<<<<<<.
>>.>>>>>>>>. # On
>>>.
<<<<<<<<.>.<<<. # The
<<<.
>>>>>>>>>>>.>.<<<<<.. # Wall
>>>>>>>. # Comma
<.
<<<<<<<<<<<<<<<.- # 0x with decrement
>.+++++++++ # x0 with increment
>.
>.>.>>>..>>.<<<<.>>>>>>. # Bottles
<<<<<<<<<.
>>.>>. # Of
<<<<.
>.>>..>>>>>. # Beer
>>>>>>>. # Stop
>. # Newline
<<<<<<<<<<<.>>>>>>>.>>>>>.<<<<<<<<<<<<<<. # Take
<<<.
>>.>>>>>>>>.<<<<<<<. # One
<<<.
>>>>>>>>>>>>>>>>>>.<<<<<<<<<<<<<<<<.>>>>>>>>>.<. # Down
>>>.
<.<<.>>>>>>>>. # And
<<<<<.
>>>>>>.<<<<<<<.<<<.. # Pass
>>>>.
>>>>>>>.<<<<<<<<<<<<<<<. # It
>>>>>>>>.
<.<<<<.<<<<<<.>>>>>>>>>>>>>>>>>>>.<<<<<<<<<<<.>>>>>>>>. # Around
<<<<. # Comma
<.
<<<<<<<<<<<<<<<.>. # Counter
>.
>.>.>>>..>>.<<<<.>>>>>>. # Bottles
<<<<<<<<<.
>>.>>. # Of
<<<<.
>.>>..>>>>>. # Beer
<<<<<<<<.
>>.>>>>>>>>. # On
>>>.
<<<<<<<<.>.<<<. # The
<<<.
>>>>>>>>>>>.>.<<<<<.. # Wall
>>>>>>>>. # Stop
>.. # Newline x2
<<<<<<<<<<<<<<<<<<<< # Reset outer loop
]
>-- # Decrement counter to only count from 7
# Last 8 loop
[
-> # Dec counter
>. # Print x0 char
>.
>.>.>>>..>>.<<<<.>>>>>>. # Bottles
<<<<<<<<<.
>>.>>. # Of
<<<<.
>.>>..>>>>>. # Beer
<<<<<<<<.
>>.>>>>>>>>. # On
>>>.
<<<<<<<<.>.<<<. # The
<<<.
>>>>>>>>>>>.>.<<<<<.. # Wall
>>>>>>>. # Comma
<.
<<<<<<<<<<<<<<.- # x with decrement
>.
>.>.>>>..>>.<<<<.>>>>>>. # Bottles
<<<<<<<<<.
>>.>>. # Of
<<<<.
>.>>..>>>>>. # Beer
>>>>>>>. # Stop
>. # Newline
<<<<<<<<<<<.>>>>>>>.>>>>>.<<<<<<<<<<<<<<. # Take
<<<.
>>.>>>>>>>>.<<<<<<<. # One
<<<.
>>>>>>>>>>>>>>>>>>.<<<<<<<<<<<<<<<<.>>>>>>>>>.<. # Down
>>>.
<.<<.>>>>>>>>. # And
<<<<<.
>>>>>>.<<<<<<<.<<<.. # Pass
>>>>.
>>>>>>>.<<<<<<<<<<<<<<<. # It
>>>>>>>>.
<.<<<<.<<<<<<.>>>>>>>>>>>>>>>>>>>.<<<<<<<<<<<.>>>>>>>>. # Around
<<<<. # Comma
<.
<<<<<<<<<<<<<<. # Count
>.
>.>.>>>..>>.<<<<.>>>>>>. # Bottles
<<<<<<<<<.
>>.>>. # Of
<<<<.
>.>>..>>>>>. # Beer
<<<<<<<<.
>>.>>>>>>>>. # On
>>>.
<<<<<<<<.>.<<<. # The
<<<.
>>>>>>>>>>>.>.<<<<<.. # Wall
>>>>>>>>. # Stop
>.. # Newline x2
<<<<<<<<<<<<<<<<<<< # Reset loop
]
# Last but 1 exception
>>. # Counter
>.
>.>.>>>..>>.<<<<.>>>>>>. # Bottles
<<<<<<<<<.
>>.>>. # Of
<<<<.
>.>>..>>>>>. # Beer
<<<<<<<<.
>>.>>>>>>>>. # On
>>>.
<<<<<<<<.>.<<<. # The
<<<.
>>>>>>>>>>>.>.<<<<<.. # Wall
>>>>>>>. # Comma
<.
<<<<<<<<<<<<<<.- # x with decrement
>.
>.>.>>>..>>.<<<<.>>>>>>. # Bottles
<<<<<<<<<.
>>.>>. # Of
<<<<.
>.>>..>>>>>. # Beer
>>>>>>>. # Stop
>. # Newline
<<<<<<<<<<<.>>>>>>>.>>>>>.<<<<<<<<<<<<<<. # Take
<<<.
>>.>>>>>>>>.<<<<<<<. # One
<<<.
>>>>>>>>>>>>>>>>>>.<<<<<<<<<<<<<<<<.>>>>>>>>>.<. # Down
>>>.
<.<<.>>>>>>>>. # And
<<<<<.
>>>>>>.<<<<<<<.<<<.. # Pass
>>>>.
>>>>>>>.<<<<<<<<<<<<<<<. # It
>>>>>>>>.
<.<<<<.<<<<<<.>>>>>>>>>>>>>>>>>>>.<<<<<<<<<<<.>>>>>>>>. # Around
<<<<. # Comma
<.
<<<<<<<<<<<<<<. # Count
>.
>.>.>>>..>>.<<<<. # Bottle
<<<.
>>.>>. # Of
<<<<.
>.>>..>>>>>. # Beer
<<<<<<<<.
>>.>>>>>>>>. # On
>>>.
<<<<<<<<.>.<<<. # The
<<<.
>>>>>>>>>>>.>.<<<<<.. # Wall
>>>>>>>>. # Stop
>.. # Newline x2
# Last 1 exception
<<<<<<<<<<<<<<<<<. # Counter
>.
>.>.>>>..>>.<<<<. # Bottle
<<<.
>>.>>. # Of
<<<<.
>.>>..>>>>>. # Beer
<<<<<<<<.
>>.>>>>>>>>. # On
>>>.
<<<<<<<<.>.<<<. # The
<<<.
>>>>>>>>>>>.>.<<<<<.. # Wall
>>>>>>>. # Comma
<.
<<<<<<<<<<<<<<.++++++++ # x with reset to 99
>.
>.>.>>>..>>.<<<<. # Bottle
<<<.
>>.>>. # Of
<<<<.
>.>>..>>>>>. # Beer
>>>>>>>. # Stop
>. # Newline
>---- # Change K to G
>>+++++++++ # Change P to Y
>++++ # Change I to M
<<<.<<<<<<<<<<<<<<<. # Go
<<.
>>>>>.<<<. # To
<<.
>>>>>.>.<<<. # The
<<<.
>>>>>>>>>.<<<<.<<<.>>>>>>.<<<<<. # Store
<<<.
>>>>>>>>>>>>.<<.>>>>>>>>. # And
<<<<<.
<<<<<<<<<<<<.>>>>>>>>>>>>>>>>>>>>.<<. # Buy
<<<<<<.
<<<<.<<<<<<<.>>>>>>>>>>>>>>>>>>.<<<<<<<<<<<<<<<<<. # Some
>>>>>>>>>>.
>>>>>>>.<<<<<<<<<<<<<<<<<<.>>>>>>.<<<<<. # More
>>>>>>>>>>>.
<.
<<<<<<<<<<<<<<.. # 99
>.
>.>.>>>..>>.<<<<.>>>>>>. # Bottles
<<<<<<<<<.
>>.>>. # Of
<<<<.
>.>>..>>>>>. # Beer
<<<<<<<<.
>>.>>>>>>>>. # On
>>>.
<<<<<<<<.>.<<<. # The
<<<.
>>>>>>>>>>>.>.<<<<<.. # Wall
>>>>>>>>. # Stop
>. # Newline x2
```
## Output:
~~Try it yourself here!~~
OK, so it seems the URL is too long to include here, so you will need to copy/paste to try it yourself.
I tested it using [this interpreter](https://copy.sh/brainfuck).
[Answer]
## [Labyrinth](https://github.com/mbuettner/labyrinth), ~~1195~~ ~~1190~~ 932 bytes
```
"{"9"
^ }
""
<
713.101.801..:611.111.89.23}!:({.23.44.001.011.711.111.411.79.23.611.501.23..:511.79.211.23.001.011.79.23.011.911.111.001.23.101.(.:111.23.101.701.79.48\.411..:101.89.23.201.111.23.511.101.801..:611.111.89.23}!:{.23.44..:801.79.911.23.101.401.611.23.(.:111.23.411..:101.89.23.201.111.23.511.101.801..:611.111.89.23}!:{
_
3`<
_ (
""""
"
{(32.111.102.32.98.101:..114.32.111:.(.32.116.104.101.32.119.97.108:..46.\\49.32.98.111.116:..108.101.32.111.102.32.98.101:..114.32.111:.(.32.116.104.101.32.119.97.108:..44.32.49.32.98.111.116:..108.101.32.111.102.32.98.101:..114.46.\71.111.32.116.111.32.116.104.101.32.115:.).111.114.101.32.97.110.100.32.98.117.121.32.115.111.109.101.32.109.111.114.101.44.32.9!9!32.98.111.116:..108.101.115.32.111.102.32.98.101:..114.32.111:.(.32.116.104.101.32.119.97.108:..46.@
)
}
<
87\\.64..:801.79.911.23.101.401.611.23.(.:111.23.411..:101.89.23.201.111.23.511
_
3`<
_ (
v"""
```
This is a bit excessive...
While Labyrinth isn't particularly good at printing strings (because you need to push all the character codes), I think it should be possible to do better than this by using more but shorter long lines and getting even crazier with the grid rotation.
As I think any golfing improvements will substantially change the structure of this code, I'll wait with an explanation until I'm out of ideas how to golf it further.
[Answer]
# Julia, ~~227~~ ~~215~~ 213 bytes
```
w=" on the wall"
b=" bottles"
o=" of beer"
k=b*o
for n=99:-1:1
println("$n$k$w, $n$k.
$(n>1?"Take one down and pass it around":"Go to the store and buy some more"), $(n>1?"$(n-1)$(k=b*"\b"^(n<3)*o)":"99$b"o)$w.
")end
```
This uses string interpolation (`"$variable"`) and ternaries to construct the output and print it to STDOUT.
Saved 14 bytes thanks to Glen O!
[Answer]
# Windows Batch, 376 bytes
Very very long and ugly:
```
@echo off
setlocal enabledelayedexpansion
set B=bottles
set C=on the wall
set D=of beer
for /l %%* in (99,-1,1) do (
set A=%%*
if !A! EQU 1 set B=bottle
echo !A! !B! !D! !C!, !A! !B! !D!.
set /a A=!A!-1
if !A! EQU 1 set B=bottle
if !A! EQU 0 (
echo Go to the store and buy some more, 99 bottles !D! !C!.
) else (
echo Take one down and pass it around, !A! !B! !D! !C!.
echo.
))
```
[Answer]
# GolfScript, 143 bytes
```
[99.{[', '\.' bottle''s of beer'@(:i!>' on the wall''.
'n].1>~;5$4<\'Take one down and pass it around'i}**'Go to the store and buy some more'](
```
~~May still be room for improvement.~~ Getting close to the final revision, I think.
[Answer]
# Python, 254 bytes
```
b,o,s,t="bottles of beer","on the wall","bottle of beer",".\nTake one down and pass it around,"
i=99;exec'print i,b,o+",",i,b+t,i-1,b,o+".\\n";i-=1;'*97
print"2",b,o+", 2",b+t+" 1",s,o+".\n\n1",s,o+", 1",s+".\nGo to the store, buy some more, 99",b,o+"."
```
Pretty straightforward, assign some of the most common phrases, print each bit from 99 to 3, then print the last lines by adding together the variables and some strings.
[Answer]
## Python 2, 204 bytes
```
n=198
while n:s="bottle%s of beer"%"s"[:n^2>1];print n%2*"GToa kteo otnhee dsotwonr ea nadn dp absusy isto maer omuonrde,, "[n>1::2]+`n/2or 99`,s,"on the wall"+[", %d %s."%(n/2,s),".\n"[:n]][n%2];n-=1
```
The spec is quite underspecified in terms of whitespace, so here I'm assuming that the last line needs to have a single trailing newline. If the spec clarifies otherwise I'll update this answer.
I'm pretty happy with this, but looking at anarchy golf I feel like this can be golfed still, possibly with a different approach.
[Answer]
# JavaScript ES6, 214 bytes
>
> *Edit:* Deleted all previous code, view edits if you want to see the older code.
>
>
>
Limited popups:
```
p='.';o=" of beer";e=o+" on the wall";i=99;u=m=>i+" bottle"+(i==1?'':'s');while(i>0){alert(u()+e+", "+u()+o+p+(--i>0?"Take one down and pass it around, "+u()+e:"Go to the store and buy some more, 99 bottles"+e)+p)}
```
Expanded:
```
p='.';
o=" of beer";
e=o+" on the wall";
i=99;
u=m=>i+" bottle"+(i==1?'':'s');
while(i>0){
alert(u()+e+", "+u()+o+p+(--i>0?"Take one down and pass it around, "+u()+e:"Go to the store and buy some more, 99 bottles"+e)+p)
}
```
@commenters: Thanks for the idea of arrow functions, saved 15 bytes
For infinite beer just use this code here, 212 bytes
```
p='.';o=" of beer";e=o+" on the wall";i=99;u=m=>i+" bottle"+(i==1?'':'s');while(i>0){alert(u()+e+", "+u()+o+p+(--i>0?"Take one down and pass it around, "+u()+e:"Go to the store and buy some more, "+u(i=99)+e)+p)}
```
[Answer]
# CJam, ~~149~~ ~~148~~ ~~146~~ ~~144~~ ~~138~~ ~~137~~ 134 bytes
```
00000000: 39 39 7b 5b 22 2c 2e 22 22 01 bd 8f 2d b4 49 b5 f5 99{[",.""...-.I..
00000011: 9d bd 21 e8 f2 72 27 df 4d 4f 22 7b 32 36 39 62 32 ..!..r'.MO"{269b2
00000022: 35 62 27 61 66 2b 27 6a 53 65 72 28 65 75 5c 2b 2a 5b'af+'jSer(eu\+*
00000033: 7d 3a 44 7e 4e 4e 32 24 32 3e 29 34 24 4a 3c 5c 4e }:D~NN2$2>)4$J<\N
00000044: 5d 73 27 78 2f 39 39 40 2d 73 2a 7d 2f 27 73 2d 5d ]s'x/99@-s*}/'s-]
00000055: 22 07 9c 4b a2 4e 15 d7 df d5 82 88 c9 d9 a7 ad 37 "..K.N..........7
00000066: 16 7e 76 22 44 33 35 2f 28 5d 22 41 90 1d b1 f3 69 .~v"D35/(]"A....i
00000077: ba 3d 05 45 81 50 af 07 e4 1b 38 f7 19 22 44 .=.E.P....8.."D
```
The above hexdump can be reversed with `xxd -r`. Try it online in the [CJam interpreter](http://cjam.aditsu.net/#code=99%7B%5B%22%2C.%22%22%01%C2%BD%C2%8F-%C2%B4I%C2%B5%C3%B5%C2%9D%C2%BD!%C3%A8%C3%B2r'%C3%9FMO%22%7B269b25b'af%2B'jSer(eu%5C%2B*%7D%3AD~NN2%242%3E)4%24J%3C%5CN%5Ds'x%2F99%40-s*%7D%2F's-%5D%22%07%C2%9CK%C2%A2N%15%C3%97%C3%9F%C3%95%C2%82%C2%88%C3%89%C3%99%C2%A7%C2%AD7%16~v%22D35%2F(%5D%22A%C2%90%1D%C2%B1%C3%B3i%C2%BA%3D%05E%C2%81P%C2%AF%07%C3%A4%1B8%C3%B7%19%22D).
At the cost of 9 extra bytes, for a total of **143 bytes**, we can avoid unprintable characters:
```
99{[", X bottles of beer on the wall."NN2$2>)4$J<\N]s'X/99@-s*}/'s-]"Take one down and pass it around"*35/("Go to the store and buy some more"\
```
### How it works
```
99{ e# For each I in [0 ... 98]:
[ e#
",." e# Push that string.
"…" e# Push a string.
{ e# Define a decoder function:
269b e# Convert the string from base 269 to integer.
25b e# Convert from integer to base 25.
'af+ e# Add 'a' to each base-25 digit.
'jSer e# Replace j's with spaces.
( e# Shift the first character from the resulting string.
eu e# Convert it to uppercase.
\+ e# Prepend it to the remaining string.
* e# Join the string/array on the stack, using the
e# generated string as delimiter.
}:D~ e# Name the function D and execute it.
e# This pushes ", x bottles of beer on the wall.".
NN e# Push two linefeeds.
2$ e# Push a copy of the generated string.
2>) e# Discard the first two characters and pop the dot.
4$ e# Push another copy of the generated string.
J< e# Discard all but the first 19 characters.
e# This pushes ", x bottles of beer on the wall".
\N e# Swap the string with the dot and push a linefeed.
]s e# Collect in an array and cast to string.
'x/ e# Split at occurrences of 'x'.
99@- e# Rotate I on top of 99 and compute their difference.
s* e# Cast to string and and join.
e# This replaces x's with 99-I.
}/ e#
's- e# Remove all occurrences of 's' for the last generated string.
] e# Wrap the entire stack in an array.
"…"D e# Join the array with separator "Take one down and pass it around".
35/( e# Split into chunks of length 35 and shift out the first.
e# This shifts out ", 99 bottles of beer on the wall.\n\n".
] e# Wrap the modified array and shifted out chunk in an array.
"…"D e# Join the array with separator "Go to the store and buy some more".
```
[Answer]
## C, ~~303~~ ~~299~~ 297 bytes
```
#define B"%d bottle%s of beer"
#define O" on the wall"
#define P printf(
#define V(n,m,S)q(n);P O);P", ");q(n);P S);q(m);P".\n");
*s[]={"","s"};q(n){P B,n,s[n>1]);}main(){for(int i=99;--i;){V(i+1,i,".\nTake one down and pass it around, ")P"\n");}V(1,99,".\nGo to the store and buy some more, ");}
```
Compile with `gcc -std=c99 -w`.
[Answer]
# Mathematica, ~~238~~ ~~226~~ ~~222~~ 224 bytes
Saved several bytes thanks to Martin Büttner.
```
a={ToString@#," bottle",If[#<2,"","s"]," of beer"}&;b=a@#<>" on the wall"&;Echo[{b@n,", ",a@n,".
"}<>If[n<2,"Go to the store and buy some more, "<>b@99<>".","Take one down and pass it around, "<>b[n-1]<>".
"]]~Do~{n,99,1,-1}
```
[Answer]
## PHP, 172 bytes
```
<?for(;100>$a=1+$a." bottle$o[21] of beer";$o="
Take one down and pass it around, $b.
".$g="$b, $a.$o")$b="$a on the wall";echo"$g
Go to the store and buy some more, $b.";
```
The most significant trick is `$o[21]`. On the first iteration, `$o` will be undefined, resulting in an empty string. On each iteration after, it refers to the first `s` of `pass`.
[Answer]
## C, 230 bytes
My first codegolfing and learning C!
```
#define B "%d bottle%s of beer"
main(i,a){for(i=99;i;i--)a=i<2,printf(B" on the wall, "B".\n%s, "B" on the wall.\n\n",i,"s"+a,i,"s"+a,a?"Go to the store and buy some more":"Take one down and pass it around",a?99:i-1,"s"+(i==2));}
```
Compiled with `gcc -std=c99 -w beer.c`
Readable (sort of):
```
#define B "%d bottle%s of beer"
main(i,a){
for (i = 99; i; i--) {
a=i<2;
printf(B" on the wall, "B".\n%s, "B" on the wall.\n\n",
i, "s"+a, i, "s"+a,
a? "Go to the store and buy some more":"Take one down and pass it around",
a? 99 : i-1, "s"+(i==2));
}
}
```
My first entry (**293 bytes**):
```
#define BOT "bottle%s of beer"
main(){
char *e[]={"Go to the store an buy some more","Take one down and pass it around"};char *z[]={"","s"};
for(int i=99;i>0;i--){int j=i>1?i-1:99;char* s=z[i>1];
printf("%d "BOT" on the wall, %d "BOT". %s, %d "BOT" on the wall.\n",i,s,i,s,e[i>1],j,z[j>1]);}}
```
Haha, I love all these nasty tricks i applied that i never though could even exist in C!
[Answer]
# [Beam](http://esolangs.org/wiki/Beam), ~~1141~~ 1109 bytes
I still have a lot of room to golf this further with all the empty spaces, but it is getting really hard to follow and breaks quite easily :)
It's very similar to the one that I posted for this [question](https://codegolf.stackexchange.com/a/62123/31347), except it goes to the store before the beer reaches 1 and the cells used for the parameters have been shifted. I've also change the layout considerably. I'll try and do an explanation once I try out a couple more layouts.
```
P'P''''>`++++++)++'''P>`+++++++++++++)'''''''''''P+++++++++++++`P```>`++\ v@@++++++++++L(`<@+p'''''''''PL<
v``P''(++++++`<P'''''''''(++++++++`<L```P'+++++P'+++P'++++++P'++++P''''(/> p++@---@``p@'''''p+++@`> `)''' 'p-@''p\
>''p:'p@'p@'\>n' >`>`)'''p@''''p@\>n'''p@''''p@-@````p@'''''p@`>`)'''''/v `P+p``@p'''(`<@-p''''''''P'+up(`<`@@/
^/``@@p'@p''/ >'''\ /-p'@p'@p``@p``/`>-'P''''''''p+@>`)''p`n`L++++++++++@S 'p@````p@````p@'''''p@`p@````p@'''''p@```p++@---@``p@'''''p-@+@`p@+++@``p-@``p@'p-@'''p-@```p++@`p@'p@''''p+@++++@`````p@'''''p-@`p@--@``p-@``p@''''p--@p@+++@``p-@''''p-@>`)'''p@'p+:`p@'p@'''p@'p@@``p@`p-@'''p-@`>`)'''p@''''p@``p@``p@'p@'p-@@'''p--@`>`)'''p@''''p@-@````p@'''''p@`>`)'''''p++@---@``p@'''''p+++@`>`)''''p-@''p@@'''p+@H
^\p@`p-@```p`//'''/ \@@'''p--@`>`)'p/``````@pS@++++++++++L`<vP+p`P-p`P-p`@ p'''(`<@-p''''@--p``@-p`@+p'@p`@--p''''@-p'@p`````@p'''@+++p''@p```\
^ \'p-@/v \ p-@''p-@`p-@``p@''''p@ -@``p-@``p@'p ++@'''p@'p+++@`p-@````p@'p-@'''p-@```p++@`p@''''p+@```p-@''''p-@@``/
^ < < <
```
Try it in the stack snippet [here](https://codegolf.stackexchange.com/questions/40073/making-future-posts-runnable-online-with-stack-snippets/57190#57190)
] |
[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/171478/edit).
Closed 5 years ago.
[Improve this question](/posts/171478/edit)
You are writing a screen scraper application monitoring a text-only chat window. Text is added at the bottom of the window.
The application takes screenshot of the chat window. If a change has occurred since last screenshot (new\_screenshot != old\_screenshot), the screenshot is saved.
After X time, all images are merged to one image, where the oldest image is on the top. This large image is send to a server for OCR, and a string of text is returned.
**Challenge:** Sort out redundant text.
Example: Chat window is 5 lines high and is initially empty. The solution must work with empty and not-empty initial chat window. More than one line can be added at each screenshot.
**Input to algorithm:**
1 Lorem ipsum dolor sit amet,
1 Lorem ipsum dolor sit amet,
2 consectetur adipiscing elit
1 Lorem ipsum dolor sit amet,
2 consectetur adipiscing elit
3 Mauris porttitor enim sed tincidunt interdum.
1 Lorem ipsum dolor sit amet,
2 consectetur adipiscing elit
3 Mauris porttitor enim sed tincidunt interdum.
4 Morbi elementum erat nec nulla auctor, eget porta odio aliquet.
1 Lorem ipsum dolor sit amet,
2 consectetur adipiscing elit
3 Mauris porttitor enim sed tincidunt interdum.
4 Morbi elementum erat nec nulla auctor, eget porta odio aliquet.
5 Nam aliquet velit vel elementum tristique.
2 consectetur adipiscing elit
3 Mauris porttitor enim sed tincidunt interdum.
4 Morbi elementum erat nec nulla auctor, eget porta odio aliquet.
5 Nam aliquet velit vel elementum tristique.
6 Donec ac tincidunt urna.
3 Mauris porttitor enim sed tincidunt interdum.
4 Morbi elementum erat nec nulla auctor, eget porta odio aliquet.
5 Nam aliquet velit vel elementum tristique.
6 Donec ac tincidunt urna.
7 Proin pretium, metus non porttitor lobortis, tortor sem rhoncus urna
4 Morbi elementum erat nec nulla auctor, eget porta odio aliquet.
5 Nam aliquet velit vel elementum tristique.
6 Donec ac tincidunt urna.
7 Proin pretium, metus non porttitor lobortis, tortor sem rhoncus urna
8 quis finibus leo lorem sed lacus.
5 Nam aliquet velit vel elementum tristique.
6 Donec ac tincidunt urna.
7 Proin pretium, metus non porttitor lobortis, tortor sem rhoncus urna
8 quis finibus leo lorem sed lacus.
1 Lorem ipsum dolor sit amet,
**Expected result:**
1 Lorem ipsum dolor sit amet,
2 consectetur adipiscing elit
3 Mauris porttitor enim sed tincidunt interdum.
4 Morbi elementum erat nec nulla auctor, eget porta odio aliquet.
5 Nam aliquet velit vel elementum tristique.
6 Donec ac tincidunt urna.
7 Proin pretium, metus non porttitor lobortis, tortor sem rhoncus urna
8 quis finibus leo lorem sed lacus.
1 Lorem ipsum dolor sit amet,
**UPDATE:** I forgot an important detail in the original challenge: The same line can come multiple times, **but never two times in a row** so just deduplicating is not enough.
[Answer]
# Japt `-R`, 11 bytes
This passes the test case but the spec still isn't clear enough
```
·ò¨ mÌò¦ mg
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.6&code=t/KoIG3M8qYgbWc=&input=IjEgTG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsCjEgTG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsCjIgY29uc2VjdGV0dXIgYWRpcGlzY2luZyBlbGl0CjEgTG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsCjIgY29uc2VjdGV0dXIgYWRpcGlzY2luZyBlbGl0CjMgTWF1cmlzIHBvcnR0aXRvciBlbmltIHNlZCB0aW5jaWR1bnQgaW50ZXJkdW0uCjEgTG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsCjIgY29uc2VjdGV0dXIgYWRpcGlzY2luZyBlbGl0CjMgTWF1cmlzIHBvcnR0aXRvciBlbmltIHNlZCB0aW5jaWR1bnQgaW50ZXJkdW0uCjQgTW9yYmkgZWxlbWVudHVtIGVyYXQgbmVjIG51bGxhIGF1Y3RvciwgZWdldCBwb3J0YSBvZGlvIGFsaXF1ZXQuCjEgTG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsCjIgY29uc2VjdGV0dXIgYWRpcGlzY2luZyBlbGl0CjMgTWF1cmlzIHBvcnR0aXRvciBlbmltIHNlZCB0aW5jaWR1bnQgaW50ZXJkdW0uCjQgTW9yYmkgZWxlbWVudHVtIGVyYXQgbmVjIG51bGxhIGF1Y3RvciwgZWdldCBwb3J0YSBvZGlvIGFsaXF1ZXQuCjUgTmFtIGFsaXF1ZXQgdmVsaXQgdmVsIGVsZW1lbnR1bSB0cmlzdGlxdWUuCjIgY29uc2VjdGV0dXIgYWRpcGlzY2luZyBlbGl0IAozIE1hdXJpcyBwb3J0dGl0b3IgZW5pbSBzZWQgdGluY2lkdW50IGludGVyZHVtLiAKNCBNb3JiaSBlbGVtZW50dW0gZXJhdCBuZWMgbnVsbGEgYXVjdG9yLCBlZ2V0IHBvcnRhIG9kaW8gYWxpcXVldC4gCjUgTmFtIGFsaXF1ZXQgdmVsaXQgdmVsIGVsZW1lbnR1bSB0cmlzdGlxdWUuIAo2IERvbmVjIGFjIHRpbmNpZHVudCB1cm5hLiAKMyBNYXVyaXMgcG9ydHRpdG9yIGVuaW0gc2VkIHRpbmNpZHVudCBpbnRlcmR1bS4KNCBNb3JiaSBlbGVtZW50dW0gZXJhdCBuZWMgbnVsbGEgYXVjdG9yLCBlZ2V0IHBvcnRhIG9kaW8gYWxpcXVldC4KNSBOYW0gYWxpcXVldCB2ZWxpdCB2ZWwgZWxlbWVudHVtIHRyaXN0aXF1ZS4KNiBEb25lYyBhYyB0aW5jaWR1bnQgdXJuYS4KNyBQcm9pbiBwcmV0aXVtLCBtZXR1cyBub24gcG9ydHRpdG9yIGxvYm9ydGlzLCB0b3J0b3Igc2VtIHJob25jdXMgdXJuYQo0IE1vcmJpIGVsZW1lbnR1bSBlcmF0IG5lYyBudWxsYSBhdWN0b3IsIGVnZXQgcG9ydGEgb2RpbyBhbGlxdWV0Lgo1IE5hbSBhbGlxdWV0IHZlbGl0IHZlbCBlbGVtZW50dW0gdHJpc3RpcXVlLgo2IERvbmVjIGFjIHRpbmNpZHVudCB1cm5hLgo3IFByb2luIHByZXRpdW0sIG1ldHVzIG5vbiBwb3J0dGl0b3IgbG9ib3J0aXMsIHRvcnRvciBzZW0gcmhvbmN1cyB1cm5hCjggcXVpcyBmaW5pYnVzIGxlbyBsb3JlbSBzZWQgbGFjdXMuCjUgTmFtIGFsaXF1ZXQgdmVsaXQgdmVsIGVsZW1lbnR1bSB0cmlzdGlxdWUuCjYgRG9uZWMgYWMgdGluY2lkdW50IHVybmEuCjcgUHJvaW4gcHJldGl1bSwgbWV0dXMgbm9uIHBvcnR0aXRvciBsb2JvcnRpcywgdG9ydG9yIHNlbSByaG9uY3VzIHVybmEKOCBxdWlzIGZpbmlidXMgbGVvIGxvcmVtIHNlZCBsYWN1cy4KMSBMb3JlbSBpcHN1bSBkb2xvciBzaXQgYW1ldCwiCi1S)
] |
[Question]
[
So task is simple, given array of numbers and result, you need to find what operations you need to use on numbers from array , to obtain requested result.
Let's make it simple for start, and allow only basic operations such as: addition, subtraction, multiplication and division.
Example:
```
Input : [5,5,5,5,5] 100
Output : 5*5*5-5*5
```
To give some advantage to languages like Java, request is to implement function, not entire program, and result can be return via parameter or print to console.
Code is scored based on amount bytes, and as it's golf code challenge, lowest score wins.
Another requirment is ~~You can get additional -10 points~~ if for array contains only digids, support solutions where you could construct numbers from following digits.
Ie
```
Input : [1,2,3,4,5] 0
Output : 12-3-4-5
```
Note that, provided outputs are proposed outputs, some cases might have more than one solution. It's up to you will you provide one or more solutions for given task.
**EDIT:**
Result has to be valid from mathematical point of view, hence division is rational division, not integer, and operation precedence is same as in classical math (first multiplication and division then addition and subtraction).
[Answer]
# Pyth, 23 bytes
Due to security reasons, `*` and `/` won't evaluate online, but they theoretically work.
```
fqeQvTms.ihQd^"+-*/"lth
```
[Test suite with only `+` and `-`.](http://pyth.herokuapp.com/?code=fqeQvTms.ihQd%5E%22%2B-%22lth&test_suite=1&test_suite_input=%5B5%2C5%2C5%2C5%2C5%5D%2C25%0A%5B1%2C2%2C3%2C4%2C5%5D%2C1&debug=0)
[Answer]
# Oracle SQL 11.2, ~~322~~ ~~304~~ 270 bytes
```
SELECT o FROM(SELECT REPLACE(SUBSTR(:1,1,1)||REPLACE(SYS_CONNECT_BY_PATH(a||SUBSTR(:1,LEVEL*2+1,1),','),','),'_')o,LEVEL l FROM(SELECT SUBSTR('+-*/_',LEVEL,1)a FROM DUAL CONNECT BY LEVEL<6)CONNECT BY LEVEL<LENGTH(:1)/2)WHERE:2=dbms_aw.eval_number(o)AND l>LENGTH(:1)/2-1;
```
:1 is the list of digits
:2 is the result searched
Un-golfed :
```
SELECT o
FROM (
SELECT REPLACE(SUBSTR(:1,1,1)||REPLACE(SYS_CONNECT_BY_PATH(a||SUBSTR(:1,LEVEL*2+1,1),','),','),'_')o,LEVEL l
FROM ( -- Create one row per operator
SELECT SUBSTR('+-*/_',LEVEL,1)a FROM DUAL CONNECT BY LEVEL<6
) CONNECT BY LEVEL<LENGTH(:1)/2 -- Create every combination of operators, one per ','
)
WHERE :2=dbms_aw.eval_number(o) -- filter on result = evaluation
AND l>LENGTH(:1)/2-1 -- keep only expressions using every digits
```
[Answer]
# TSQL(sqlserver 2016) ~~310~~ ~~294~~ 280 bytes
What a wonderful opportunity to write ugly code:
Golfed:
```
DECLARE @ varchar(max)= '5,5,5'
DECLARE @a varchar(20) = '125'
,@ varchar(max)='';WITH D as(SELECT @a a UNION ALL SELECT STUFF(a,charindex(',',a),1,value)FROM STRING_SPLIT('*,+,./,-,',',')x,d WHERE a like'%,%')SELECT @+=a+','''+REPLACE(a,'.','')+'''),('FROM D WHERE a not like'%,%'EXEC('SELECT y FROM(values('+@+'null,null))g(x,y)WHERE x='+@b)
```
[Try it online](https://data.stackexchange.com/stackoverflow/query/501607/find-operations-required-to-get-result)
Readable:(insertion of decimal point(.) and removal of the same is necessary in order for sql to accept that 4/5 is not 0 - well removal is for the people testing it)
```
DECLARE @a varchar(max)= '5,5,5'
DECLARE @b varchar(20) = '5'
,@ varchar(max)=''
;WITH D as
(
SELECT @a a
UNION ALL
SELECT STUFF(a,charindex(',',a),1,value)
FROM STRING_SPLIT('*,+,./,-,',',')x,d
WHERE a like'%,%'
)
SELECT @+=a+','''+REPLACE(a,',','')+'''),('
FROM D
WHERE a not like'%,%'
EXEC('SELECT y FROM(values('+@+'null,null))g(x,y)WHERE x='+@b)
```
This solution can also handle these types of input:
>
> Input :[1,2,3,4,5] 0 Output : 12-3-4-5
>
>
>
[Answer]
# JavaScript (ES6), ~~165~~ 147 bytes
```
a=>o=>(c=[],i=c=>{for(j=0;!((c[j]?++c[j]:c[j]=1)%5);)c[j++]=0},eval(`while(eval(e=(a+'').replace(/,/g,(_,j)=>'+-*/'.charAt(c[~-j/2])))!=o)i(c);e`))
```
Nested `eval`... lovely.
```
f=a=>o=>(c=[],i=c=>{for(j=0;!((c[j]?++c[j]:c[j]=1)%5);)c[j++]=0},eval(`while(eval(e=(a+'').replace(/,/g,(_,j)=>'+-*/'.charAt(c[~-j/2])))!=o)i(c);e`))
console.log(f([5,5,5,5,5])(100))
console.log(f([1,2,3,4,5])(0))
console.log(f([3,4])(0.75))
console.log(f([3,4,5,6])(339))
```
[Answer]
## Python 3, ~~170~~ 155 bytes
```
from itertools import*
def f(n,o):print({k for k in[''.join(map(str,sum(j,())))[1:]for j in[zip(x,n)for x in product('+-*/',repeat=len(n))]]if eval(k)==o})
```
Create a generator with all possible orders of the operators, combine that with the numbers, then eval until we get the answer.
<https://repl.it/C2F5>
[Answer]
# Python, ~~195~~ 186 bytes
Here's an atrocious way of doing it.
```
def x(i,r):
t=""
from random import choice as c
while True:
for j in i:
t+=str(j)
if c([0,1]):t+="."+c("+-/*")
t=t.strip("+-*/.")+"."
v=eval(t)
if v == r:print t
t=""
```
The function `x` accepts an argument of a `list` and a `result` - `x([1,2,3,4,5], 15)` for example.
The program begins a loop where we begin randomly selecting if we should append `"+", "-", "*", or "/"` between each number, or if we should concatenate them together. This seemed like a more concise option than actually going through permutations and trying every combination to find every result, and although it takes longer to run and is *much* less efficient. (Fortunately that's not a concern in this context!)
It also appends "." to each number to avoid doing integer-rounded operations like `6/4 = 1`. It then `eval`s our expression and determines if the result equal to what we are expecting, and if so, outputs the expression.
This program never exits - it will keep continually outputting results until killed.
**EDIT 1**: Remove unnecessary newlines where one-line `if` statements can be used.
[Answer]
## Matlab, 234 ~~238~~ ~~258~~ bytes
*I'm assuming based on the limitations of the other answers that the number order of the input array is maintained by fiat.*
```
n=length(x)-1
k=n*2+2
p=unique(nchoosek(repmat('*-+/',1,n),n),'rows')
p=[p char(' '*~~p(:,1))]'
c=char(x'*~~p(1,:))
o=p(:,r==cellfun(@eval,mat2cell(reshape([c(:) p(:)]',k,[]),k,0|p(1,:))))
reshape([repmat(x',size(o,2),1) o(:)]',k,[])'
```
This code takes a string of numbers `x`, say `x = '12345'` and a result `r`, say `r = 15` and returns all of the strings of expressions you can evaluate to get `r` from `x` using the four operators.
I've used two different length-equivalent ways of avoiding using `ones(length())`-type or `repmat(length())`-type expressions: `~~p(1,:)` which returns not-not values in `p` (i.e., a list of `1`s the samelength as the first dimension of `p`) and `0|p(:,1)` which returns 0 or is-there-a-value-in-`p` (i.e., a list of `1`s the same length as the second dimension of `p`).
Matlab doesn't have an `nchoosek` *with replacement* method, so I've duplicated the operators the correct number of times, computed the whole space of `nchoosek` for that larger selection of operators, and then used a `unique` call to pare the result down to what it should be (removing equivalent combinations like '\*\*\*+' and '\*\*\*+'). I add a trailing space to match the length of the input vector for concatenation purposes and then compose the operator strings with the input strings into the columns of a matrix. I then evaluate the expressions columnwise to get results and find the order of operators that corresponds to those columns with results that match our input `r`.
Test: `x = '12345'`, `r = 15`:
```
1*2*3+4+5
1+2+3+4+5
1-2*3+4*5
```
If I had to take an array of double precision values, I'd need `x = num2str(x,'%d');` in order to convert the digits to a string, adding 21 (20 without the `;`) to my score. \*The extra bytes were semicolons I left in purely so that anyone running this code won't see their command prompt blow up with long arrays. Since my edit produces a giant pile of warnings about logicals and colon-operands now anyway, I've removed the semicolons in the new version.
Edit 2: Forgot to replace a `2*n+2` with `k`.
Old answer:
```
n=length(x)-1;
p=unique(nchoosek(repmat(['*','-','+','/'],1,n),n),'rows');
l=length(p);
p=[p repmat(' ',l,1)]';
c=reshape([repmat(x',l,1) p(:)]',n*2+2,[]);
o = p(:,r == cellfun(@eval, mat2cell(c,n*2+2,ones(l,1))));
reshape([repmat(x',size(o,2),1) o(:)]',n*2+2,[])'
```
[Answer]
# JavaScript (ES6), 88 bytes
```
a=>o=>eval(`while(eval(e=(a+'').replace(/,/g,_=>'+-*/'.charAt(Math.random()*5)))!=o);e`)
```
Threw in a little randomness to the mix. Much easier than systematically iterating through the combinations.
## Test Suite
```
f=a=>o=>eval(`while(eval(e=(a+'').replace(/,/g,_=>'+-*/'.charAt(Math.random()*5)))!=o);e`)
console.log(f([5,5,5,5,5])(100))
console.log(f([1,2,3,4,5])(0))
console.log(f([3,4])(0.75))
console.log(f([3,4,5,6])(339))
```
[Answer]
# PHP, 108 bytes
```
for(;$i=$argc;eval("$s-$argv[1]?:die(\$s);"))for($s="",$x=$p++;--$i>1;$x/=4)$s.="+-*/"[$s?$x&3:4].$argv[$i];
```
takes input from command line arguments in reverse order. Run with `-r`.
**breakdown**
```
for(; # infinite loop:
$i=$argc; # 1. init $i to argument count
eval("$s-$argv[1]?:" # 3. if first argument equals expression value,
."die(\$s);") # print expression and exit
)
for($s="", # 2. create expression:
$x=$p++; # init map
--$i>1; # loop from last to second argument
$x/=4) # C: shift map by two bits
$s.="+-*/"[$s?$x&3:4] # A: append operator (none for first operand)
.$argv[$i]; # B: append operand
```
[Answer]
## [Perl 5](https://www.perl.org/) with `-pa`, 46 bytes
```
$"="{,\\*,/,+,-}";$x=<>;($_)=grep$x==eval,<@F>
```
[Try it online!](https://tio.run/##K0gtyjH9/19FyVapWicmRktHX0dbR7dWyVqlwtbGzlpDJV7TNr0otQDItU0tS8zRsXFws/v/31DBSMFYwUTBlMuAy1QBCrkMDQz@5ReUZObnFf/XLUjMAQA "Perl 5 – Try It Online")
] |
[Question]
[
[Related, both rope, nail and falling, but reversed and some other differences](https://codegolf.stackexchange.com/questions/106745/no-strings-attached)
Consider a loop of rope hanging on `n` nails on a row. Given a table showing whether the rope would fall down when each possible set of nails were removed, please provide a possible roping way. You may assume such a solution exist.
Here, "fall down" means the rope can be moved far away from the nails. That means, we treat a rope just placing on nails as "fall down".
We express a roping way as the space where the rope go up/down the line where nails are placed, left-most space as space 0 and right-most space as space `n`.
Sample input:
```
(whether removed or not)
Nail1 Nail2 Nail3 Nail4 Fall
0 0 0 0 0
0 0 0 1 0
0 0 1 0 0
0 0 1 1 0
0 1 0 0 0
0 1 0 1 0
0 1 1 0 0
0 1 1 1 0
1 0 0 0 0
1 0 0 1 0
1 0 1 0 0
1 0 1 1 1
1 1 0 0 0
1 1 0 1 0
1 1 1 0 0
1 1 1 1 1
```
Sample output
```
0 1 2 4
```
Explanation
[](https://i.stack.imgur.com/7kAx2.png)
In this case, if we draw a horizontal line through the nails, it intersects the rope at position `0, 1, 2, 4` in the order of the rope. Note that because the loop is closed, if you use this output format then the length of the output is always even.
Sample input:
```
(whether removed or not)
Nail1 Nail2 Fall
0 0 0
0 1 1
1 0 1
1 1 1
```
Sample output
```
1 2 0 1 2 0
```
Explanation
[](https://i.stack.imgur.com/JRCMo.png)
The way to input is quite free. You can input as function, map, array with removed nail set in fixed order, or other reasonable method. Inverting either or both nail logic and fall logic are also allowed. Output should be array-like, so string separated by some char is also allowed.
Code golf, shortest code win. Optimizing the length of the output but weaker in code length won't be accepted, but may be upvoted.
]
|
[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/139824/edit).
Closed 3 years ago.
[Improve this question](/posts/139824/edit)
Given an integer `n` as input, return a list containing `n`, repeated `n` times. For example, the program would take `5` and turn it into `[5,5,5,5,5]`. The elements need to be integers, not strings. No built-in functions that accomplish the task are allowed.
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so standard rules apply.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 1 byte
```
x
```
[Try it online!](https://tio.run/##y0rNyan8/7/i////pgA "Jelly – Try It Online")
Note that this is **not** the “repeat `n` `n` times” built-in — its function is more general than that. For example `4,5,6x1,2,3` equals `[4, 5, 5, 6, 6, 6]`. Given only one argument, Jelly just happens to use it as both the left and right argument for the supplied link, but this functionality is not *inherent* to `x`.
If this doesn’t count, there are various fun 2-byte alternatives:
```
x` ṁ` Ra Rị R» a€ oR oḶ oṬ oẊ Ḷị Ḷ» Ṭị Ṭ» Ẋị Ẋ» ị€ ṛ€ ȧ€ »€
```
etc.
[Answer]
# [Python 3](https://docs.python.org/3/), 14 bytes
```
lambda k:[k]*k
```
[Try it online!](https://tio.run/##K6gsycjPM/6fZhvzPycxNyklUSHbKjo7Viv7f1p@kUKmQmaeQlFiXnqqhoGOoaGmFZdCQVFmXolGpo66rp26TppGpqbmfwA "Python 3 – Try It Online")
[Answer]
# [Operation Flashpoint](https://en.wikipedia.org/wiki/Operation_Flashpoint:_Cold_War_Crisis) scripting language, ~~50~~ 46 bytes
```
f={a=[];t=_this;while{count a<t}do{a=a+[t]};a}
```
**Call with:**
```
hint format["%1", 5 call f]
```
**Output:**
[](https://i.stack.imgur.com/oyafl.jpg)
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), 2 bytes
Five equally short solutions. Last two are courtesy of [Zacharý](https://codegolf.stackexchange.com/users/55550/zachar%c3%bd).
---
```
⍴⍨
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///v@JR24RHvVse9a4AshVMAQ "APL (Dyalog Unicode) – Try It Online")
`⍴` cyclically **r**eshape
`⍨` self
---
```
/⍨
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///v@JR2wT9R70rgCwFUwA "APL (Dyalog Unicode) – Try It Online")
`/` replicate
`⍨` self
---
```
\⍨
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///v@JR24SYR70rgCwFUwA "APL (Dyalog Unicode) – Try It Online")
`\` expand
`⍨` self
---
```
⌿⍨
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///v@JR24RHPfsf9a4AshVMAQ "APL (Dyalog Unicode) – Try It Online")
`⌿` replicate along first (and only) axis
`⍨` self
---
```
⍀⍨
```
`⍀` expand along first (and only) axis
`⍨` self
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///v@JR24RHvQ2PelcA2QqmAA "APL (Dyalog Unicode) – Try It Online")
[Answer]
# Mathematica, 10 bytes
```
#~Table~#&
```
[Answer]
# [Proton](https://github.com/alexander-liao/proton), 8 bytes
```
n=>[n]*n
```
[Try it online!](https://tio.run/##KyjKL8nP@59m@z/P1i46L1Yr739BUWZeiUaahqmm5n8A "Proton – Try It Online")
[Answer]
# Octave, 12 bytes
```
@(n)~(1:n)+n
```
[Try it online!](https://tio.run/##y08uSSxL/f/fQSNPs07D0CpPUzvvf2JesYap5n8A "Octave – Try It Online")
[Answer]
# JavaScript (ES6), 19 bytes
```
n=>Array(n).fill(n)
```
---
## Try it
```
o.innerText=(f=
n=>Array(n).fill(n)
)(i.value=8);oninput=_=>o.innerText=f(+i.value)
```
```
<input id=i type=number><pre id=o>
```
[Answer]
# [Pyth](https://pyth.readthedocs.io), 2 bytes
```
*]
```
**[Test suite](http://pyth.herokuapp.com/?code=%2a%5D&input=5&test_suite=1&test_suite_input=0%0A1%0A2%0A3%0A4%0A5&debug=0).**
---
```
*]QQ - Full program with implicit input
] - Turn the input into a list.
* - Repeat it a number of times equal to the input.
```
[Answer]
# [Haskell](https://www.haskell.org/), 13 bytes
```
f n=n<$[1..n]
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P00hzzbPRiXaUE8vL/Z/bmJmnoKtQkFRZl6JgopCmoLpfwA "Haskell – Try It Online") Usage: `f 5` yields `[5,5,5,5,5]`. For `n=5`, `[1..n]` yields the list `[1,2,3,4,5]`. `n<$` replaces each element of this list with `n`.
[Answer]
# [R](https://www.r-project.org/), 18 bytes
```
array(n<-scan(),n)
```
[Try it online!](https://tio.run/##K/r/P7GoKLFSI89Gtzg5MU9DUydP87/pfwA "R – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 2 bytes
```
Fˆ
```
[Try it online!](https://tio.run/##MzBNTDJM/f/f7XTb//@mAA "05AB1E – Try It Online")
[Answer]
# [Dodos](https://github.com/DennisMitchell/dodos), 76 bytes
```
f f r 2
2
r
r d
f s t f
d
dip f s t
f
t
dot f
dot
s
s dip
f
dab
```
[Try it online!](https://tio.run/##HYlLCoBADEPXzSlyhll4H6UUXFVa718zEsjnxdOzZywYLC4smFSwokO0@TKg6vfDf4pC5rmPHWhYUz/2Pq@ZOT4 "Dodos – Try It Online")
# Explanation:
`f` is an alias for `dab` (tail).
`s` is subtraction, as explained on the wiki: **(x, y) → (0, y−x)** when **x ≤ y**.
`t` maps **(a, b, c…)** to **(b+c+…, a+b+c+…)**.
`f s t` maps **(a, b, c…)** to **a**. This is our “head” function.
`d` dips only the head of its argument: **(a, b, c…) → (|a−1|, b, c…)**
`r` is the main repetition logic. We map **(a, b)** to **(\*r(|a−1|, b), b)**.
For example, **r(4, 7)** will evaluate as
```
r(4, 7)
= r(3, 7), 7
= r(2, 7), 7, 7
= r(1, 7), 7, 7, 7
= r(0, 7), 7, 7, 7, 7
→ This would call r(1, 7), but (1, 7) ≥ (0, 7), so surrender!
= 0, 7, 7, 7, 7, 7.
```
Finally, we define `2`, which maps **n → (n, n)**, and define `main` as `f f r 2`, computing **r(n, n)** and chopping off the first two elements.
[Answer]
# [Japt](https://github.com/ETHproductions/japt/), 2 bytes
```
ÆU
```
[Test it](https://ethproductions.github.io/japt/?v=1.4.5&code=xlU=&input=OA==)
---
## Explanation
Implicit input of integer `U`. Generate an array of integers from `0` to `U-1`. Fill it with `U`. Implicit output of resulting array.
[Answer]
# TeX, 81 bytes
```
\newcommand{\f}[1]{#1\count0=2\loop,#1\advance\count0 by1\ifnum\count0<#1\repeat}
```
## Usage
```
\documentclass[12pt,a4paper]{article}
\begin{document}
\newcommand{\f}[1]{#1\count0=2\loop,#1\advance\count0 by1\ifnum\count0<#1\repeat}
\f{5}
\f{10}
\end{document}
```
[](https://i.stack.imgur.com/8xkEq.png)
[Answer]
# [Husk](https://github.com/barbuz/Husk), 2 bytes
```
´R
```
[Try it online!](https://tio.run/##yygtzv7//9CWoP///5sCAA "Husk – Try It Online")
```
´ -- Apply next function twice to same argument
R -- given an integer n and some element, replicate the element n-times
```
---
### Polite alternative (3 bytes)
```
ṠIR
```
[Try it online!](https://tio.run/##yygtzv7//@HOBZ5B////NwUA "Husk – Try It Online")
[Answer]
# Haskell (14 bytes)
```
replicate>>=id
```
Thanks to @nimi, I don't need any import anymore. Yay!
It's a function that takes an integer argument; for example, the following returns `[5,5,5,5,5]`:
```
(replicate>>=id) 5
```
[Answer]
# [Java (OpenJDK 8)](http://openjdk.java.net/), ~~50~~ 48 bytes
```
n->java.util.Arrays.stream(new int[n]).map(i->n)
```
[Try it online!](https://tio.run/##bVDBasMwDD3HX6GjTVezndMVehnssO3QY@nBS53gLpGNrXQNI9@eKWnWQTcQPCG993jS0ZzM0geLx8PH4JrgI8GRZ7olV@tNjKZLufizKFssyHnUT3PzDydRtKbRz0jbqcuFCO177QooapMSvBiH4ktk8zCRIYaTdwdoeCVZ5bDa7cHEKimRMTUrfQTpkMDBI9znDCt4GHGxYMZEybZdItto35IO7EA1yssdmvzFU9Yu0Vv5Kp3i2bSUSqmc1b3gus10PQGuQo5wnjP9vGDFNFvZePfLX0PFOUU24HJ9@9X5PxLtJ7DdDvdKNyZIt1yjGsYs0VIbESptQqg7eR4D9qIfvgE "Java (OpenJDK 8) – Try It Online")
*-2 bytes thanks to @Jakob*
Inspired by the comments in @OlivierGrégoire's post, and optimized a little further. Takes an integer input, creates an IntStream of `n` elements, then maps each element to `n` and returns it.
[Answer]
# [Perl 5](https://www.perl.org/), ~~18~~ 14 bytes
-4 bytes thanks to @DomHastings
```
sub{(@_)x"@_"}
```
[Try it online!](https://tio.run/##K0gtyjH9n1upoJKmYPu/uDSpWsMhXrNCySFeqfa/NVdBUWZeiUJWfmaehpKOkg5Qla6dhqmmpo6CUkyekvV/AA "Perl 5 – Try It Online")
Is `x` a builtin that does the entire task? Sort of? Not really? Rules unclear?
Edit: Yeah, probably it's fine.
[Answer]
# J, 2 bytes
```
$~
```
Same as the APL answer: reflexively shape the input. In other words:
```
$~ y
y $ y
NB. y copies of y
```
[Answer]
# [Brainbash](https://github.com/ConorOBrien-Foxx/Brainbash), 39 bytes
```
>-[-[-<]>>+<]>->#[->+>+<<]>>[-<;<<.>>>]
```
[Try it online!](https://tio.run/##SypKzMxLSizO@P/fTjcaCG1i7ey0gYSunXK0rp02kA0SAYpb29jo2dnZxf7/bwoA "Brainbash – Try It Online")
Prints `N` `N` times. Works by generating 32, taking input, then duplicating the input twice, then output the first for each 1 in the second.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 55 bytes
```
int*f(k){int*r=malloc(k*4),a=k;for(;a-->0;)r[a]=k;k=r;}
```
[Try it online!](https://tio.run/##TU7bioMwEH3vVxwChUxrwEL7sqnth4gswa1LUGNJbGFX/HZ3ksLWvOScmXOZWn3X9bJYN@4a2dIUgS9603VDLdvdkTJTtLoZvNRGqUuuyZem4lFbeD0vz8F@wXhvfj7vnr0y@tHZMGZgiGB/b4QJMSByiwK55u@cVoz2e0KyNlJs7TaILNlLW2X/MigccAWvBD4gBGnMm1Q93kLqhIst7xyoC0rWO5auz2uko9f0/hiDFNUrKyb0xjpJ0wb8UmxO@k0Oa3JckxOTeTn9AQ "C (gcc) – Try It Online")
Returns a list of `k` integers.
[Answer]
# [Röda](https://github.com/fergusq/roda), 10 bytes
```
{[[_]*_1]}
```
[Try it online!](https://tio.run/##K8pPSfxfzcWZpmBlqxDzvzo6Oj5WK94wtvZ/LRdXbmJmngJQsqAoM69EoaC0OEPDVFOhRiFNQ5Or9j8A "Röda – Try It Online")
Explanation:
```
{[[_]*_1]}
{ } /* Anonymous function */
_ /* The input (_1) */
[ ] /* As a list */
*_1 /* Repeated _1 times */
[ ] /* Pushed to the stream */
```
[Answer]
# [Groovy](http://groovy-lang.org/), 9 bytes
```
{[it]*it}
```
[Try it online!](https://tio.run/##Sy/Kzy@r/F9QlJlXkpOnofG/OjqzJFYrs6T2v6aGmaGm5n8A "Groovy – Try It Online")
---
Perhaps the most competitive groovy answer I've done to date.
[Answer]
# [brainfuck](https://github.com/TryItOnline/tio-transpilers), 16 bytes
```
[->+>+<<]>[->.<]
```
[Try it online!](https://tio.run/##SypKzMxLK03O/q/zP1rXTttO28Ym1g7I0rOJ/f9fEQA "brainfuck – Try It Online")
## The breakdown:
```
[->+>+<<] Duplicate 'n' into the next 2 cells to the right
> Move to the first duplicate
[->.<] Print 'n', 'n' times
```
As I'm sure you're aware, brainfuck takes input and output values as ASCII characters. So a `!` is represented as the value 33.
[Answer]
# Coreutils, sed, 14 bytes
```
yes $1|sed $1q
```
As a zsh function, 20 19 bytes:
```
f(){yes $1|sed $1q}
```
[Try it online!](https://tio.run/##qyrO@P8/TUOzujK1WEHFsKY4NQVIFdb@T1Mw@w8A)
[Answer]
# [MATL](https://github.com/lmendo/MATL), ~~4~~ 3 bytes
```
tY"
```
[Try it online!](https://tio.run/##y00syfn/vyRS6f9/UwA "MATL – Try It Online")
**Explanation:**
```
t % duplicate elements
Y" % replicate elements of array
% (implicit) convert to string and display
```
[Answer]
# [Java (OpenJDK 8)](http://openjdk.java.net/), ~~58~~ 56 bytes
```
n->{int a[]=new int[n],i=n;for(;i-->0;)a[i]=n;return a;}
```
[Try it online!](https://tio.run/##RU9Na8MwDL33V@gY08WUXV0HdinssFOPIQctTYqyVA623BFKfntmN4UJhD7e4@lpwDuWbup4uPysU/weqYV2xBDgC4nhsQN4bYOgpHJ3dIFbwoqzeOJr3QD6a1CZCTAkOR2FRt1HboUc60@W06s/EkvdVNDblcvqkSbAurHc/UJGuHkjy6Z3vjBUltXBKKwp4cZ3Ej0DmmWFZ5jntczMIgQWDiaVo4X33Oz3CjZDAOc5SHfTLoqekmEZufh3@eE9zkGL254peo3TNM4FKaW2G8su57L@AQ "Java (OpenJDK 8) – Try It Online")
-2 bytes thanks to @KevinCruijssen
[Answer]
# [cQuents](https://github.com/stestoltz/cQuents) v0, 3 bytes
```
::n
```
[Try it online!](https://tio.run/##Sy4sTc0rKf7/38oq7/9/UwA "cQuents – Try It Online")
## Explanation
```
:: Mode: sequence 2. Given input n, output the sequence n times
n Each item in the sequence is n
```
[Answer]
# [Swift 3](https://www.swift.org), 29 bytes
```
{n in(0..<n).map{_ in n}}
```
**[Try it here!](http://swift.sandbox.bluemix.net/#/repl/599ad86ca5f97c4ee18da7ff)**
# [Swift 3](https://www.swift.org), 30 bytes
```
{Array(repeating:$0,count:$0)}
```
**[Try it here!](http://swift.sandbox.bluemix.net/#/repl/599abf047a55b2295b134530)**
] |
[Question]
[
**This question already has answers here**:
[Compute the multinomial coefficient](/questions/69424/compute-the-multinomial-coefficient)
(17 answers)
Closed 5 years ago.
Given a list of stack heights, calculate the number of ways those heights could have been arrived at by stacking blocks one at a time. Shortest code wins.
Test cases:
```
[2, 2] 6
[3,3,3] 1680
[1,5,9,1] 480480
[] 1
[10] 1
[2,2,2,10] 720720
```
Reference Python implementation:
```
def stacking_count(stacks):
if sum(stacks) == 0:
return 1
count = 0
for i, n in enumerate(stacks):
if n == 0:
continue
stacks[i] -= 1
count += stacking_count(stacks)
stacks[i] += 1
return count
```
[Answer]
# [Python 3](https://docs.python.org/3/), 85 bytes
```
f=lambda a:sum(f(a[:i]+[a[i]-1]+a[i+1:])for i in range(len(a))if a[i])if sum(a)else 1
```
[Try it online!](https://tio.run/##FYwxCoAwDEWvkrGhOpRuBU9SMkRsNVCjVB08fbXw4C3v//O9t0N9a3kqvM8LA4fr2U02HIOQjRyFRkf2t3WBMB8VBEShsq7JlKSGESVDD7v7mjGVK4FrZxW9/7PoB@gQYvsA "Python 3 – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 6 bytes
```
;@S!:/
```
[Try it online!](https://tio.run/##y0rNyan8/9/aIVjRSv/////RhjqmOpY6hrEA "Jelly – Try It Online")
-7 bytes thanks to Jonathan Allan
] |
[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/152109/edit).
Closed 6 years ago.
[Improve this question](/posts/152109/edit)
### Rules
Given a list of integer coordinates, **l**, with a length of at least 4, and an integer **n** such that **n** is smaller than the length of **l** (but at least 3), return the largest area of an **n**-sided polygon satisfies:
* is simple (not self-intersecting).
* has all the coordinates of its **n** vertices in the list **l**.
* has no three consecutive collinear vertices.
Note that the polygon given in the input should comply to the three points above as well.
### Test Cases
Here are a few test cases:
```
[(0,0), (0,-1), (-1,-1), (-1,0)], 3 -> 0.5
[(0,0), (1,0), (2,1), (2,2), (1,3), (0,3), (-1,2), (-1,1)], 3 -> 3
[(0,0), (1,0), (2,1), (2,2), (1,3), (0,3), (-1,2), (-1,1)], 5 -> 5.5
[(0,0), (1,0), (2,1), (2,2), (1,3), (0,3), (-1,2), (-1,1)], 6 -> 6
```
You can try any test cases you like [here](https://repl.it/@jdevine/EdibleWeepyBengaltiger).
Make your code as short as possible.
[Answer]
# [Python 2](https://docs.python.org/2/), 172 bytes
-1 byte thanks to [J843136028](https://codegolf.stackexchange.com/users/55749/j843136028)
bug fix thanks to [Jonathan Frech](https://codegolf.stackexchange.com/users/73111/jonathan-frech)
```
from itertools import*
def f(l,n,L=()):
for p in combinations(l,n):
r=0;j=-1
for i in range(n):r+=(p[j][0]+p[i][0])*(p[j][1]-p[i][1]);j=i
L+=abs(r/2.),
print max(L)
```
[Try it online!](https://tio.run/##pY1BUsMwDEX3OYWWUuNQOxlYwPgGuUHGixRiUKexPY4XcPrUrjsMbGH1NP8/SeErfXjX77uNfgVOS0zeXzbgNfiYDs3bYsHiRTgxaiR6bsD6CAHYwatfT@zmxN5txSglRC1fzrpTeSwiFzHO7n3B3MdWY5jOZpKmDRMX0qEmynS3RBnK@5zXx1bPpw3jsX8g0UCI7BKs8yeOtFucUApJAlBV9EJV9DUcCmRFp2qaqcgIeKLmxwEpOnVvvwdZtOGX9oc/j/89MNB@BQ "Python 2 – Try It Online")
] |
[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/151437/edit)
Given a drawing of the letter shoot system, where an existing piece of pipe is marked with a \*, and an empty spot is marked with a ., your task is to compile a lexicographically sorted list of index tuples [entry row, entry column, exit row, exit column], where each index is 0-based. Entry and exit points are always on the border of the map. Mail can travel horizontally, vertically and diagonally and will usually maintain its direction, unless it is forced by the pipes to turn into a curve. Only 45 degree turns are possible -- the system is built in such a way that mail capsules will never get stuck.
It is guaranteed that pipes at the entry points have exactly one neighboring pipe, and that that neighbor is not on the same border as the entry point. It is also guaranteed that mail will eventually reach an exit point.
Example
```
For
pipesPlan =
[[".",".","."],
["*","*","*"],
[".",".","."]]
the output should be
airMail(pipesPlan) = [[1,0,1,2], [1,2,1,0]].
```
For
```
pipesPlan =
[[".", ".", "*", ".", "."],
[".", ".", "*", ".", "."],
["*", "*", "*", "*", "*"],
[".", ".", "*", ".", "."],
[".", ".", ".", "*", "."]]
the output should be
airMail(pipesPlan) = [[0,2,4,3], [2,0,2,4], [2,4,2,0], [4,3,2,0]].
```
[input] array.char pipesPlan
```
The rectangular plan of pipes, where an * marks a piece of pipe and a.
marks an empty spot.
```
[output] array.integer
```
A lexicographically sorted list of tuples [entry row, entry column,
exit row, exit column] that specify where a letter shot from entry row,
entry column would end up according to the pipesPlan. Indices are 0-based.
```
]
|
[Question]
[
Based on the interpretation user [@ThePirateBay](https://codegolf.stackexchange.com/users/72349/thepiratebay) made from the **[first version](https://codegolf.stackexchange.com/revisions/140321/1)** of my own challenge
### [Output diagonal positions of me squared](https://codegolf.stackexchange.com/questions/140321/output-diagonal-positions-of-me-squared)
now I challenge you to make ASCII art that draws diagonal lines based on a square character matrix based on a given number `n`.
# Input
A number n.
# Output
A square matrix of size `n^2` which outputs diagonals represented by the adequate one of the `\ X /`chars. All other positions are to be fulfilled with `#` chars.
# Examples:
```
1
X
2
\/
/\
3
\#/
#X#
/#\
4
\##/
#\/#
#/\#
/##\
5
\###/
#\#/#
##X##
#/#\#
/###\
```
There will be no accepted answer. I want to know the shortest code for each language.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 14 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
⁼þµḤ+Ṛị“/\X#”Y
```
A monadic link taking a number and returning a list of characters; or a full program printing the result.
**[Try it online!](https://tio.run/##AScA2P9qZWxsef//4oG8w77CteG4pCvhuZrhu4vigJwvXFgj4oCdWf///zU "Jelly – Try It Online")** or see [[1-12] in one go](https://tio.run/##ATYAyf9qZWxsef//4oG8w77CteG4pCvhuZrhu4vigJwvXFgj4oCdWf8xMsOH4oKsauKBvsK2wrb//zI "Jelly – Try It Online").
### How?
```
⁼þµḤ+Ṛị“/\X#”Y - Link: number, n
þ - outer product (implicit range build on left AND right from n) with:
⁼ - is equal (yields a table of 0s except the main diagonal is 1s)
µ - monadic chain separation, call that I
Ḥ - double (change all the 1s to 2s)
Ṛ - reverse I (a table of 0s with 1s as the anti-diagonal)
+ - add (vectorises to make a table of zeros with 2s on the diagonal,
- 1s on the anti-diagonal and, if the meet, a 3 at the centre)
“/\X#” - literal list of characters ['/','\','X','#']
ị - index into (replaces... 1:'/'; 2:'\'; 3:'X'; and 0:'#')
Y - join with newline characters
- as a full program: implicit print
```
[Answer]
# [Python 2](https://docs.python.org/2/), 83 bytes
```
n=input()
for i in range(n):l=['#']*n;l[i],l[~i]='\X/X'[i-~i==n::2];print''.join(l)
```
[Try it online!](https://tio.run/##BcGxCsIwFAXQ3a8IOLxErIWCS8r7j0LM0MHWK@EmhHRw6a/Hc8qvfTKn3qlgOZp1ly1XAwOaunJ/WzqfNMhV4o1zCoj3FE5EldcyLhIwnFCl91OcSwWbyOObQZtc788/ "Python 2 – Try It Online\"teglj9E0C02tfdvLC3CYsdnbOhi0XQSWav0mgo@l9/QM \"Python 2 – Try It Online")
-3 thanks to [Jonathan Frech](https://codegolf.stackexchange.com/users/73111/jonathan-frech) and [G B](https://codegolf.stackexchange.com/users/18535/g-b).
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~73 61~~ 59 bytes
```
->n{(0...n).map{|x|w=?#*n;w[x],w[~x]=?\\,n==1+x*2??X:?/;w}}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1y6vWsNAT08vT1MvN7GguqaiptzWXlkrz7o8uiJWpzy6riLW1j4mRifP1tZQu0LLyN4@wspe37q8tva/hqGenqEBXF9BaUmxQrS6rq6uuk4aUHNs7X8A "Ruby – Try It Online")
[Answer]
# [SOGL V0.12](https://github.com/dzaima/SOGL), 16 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md)
```
.↔╝Ζ #ŗ.2%?╬3←╬¡
```
[Try it Here!](https://dzaima.github.io/SOGLOnline/?code=LiV1MjE5NCV1MjU1RCV1MDM5NiUyMCUyMyV1MDE1Ny4yJTI1JTNGJXUyNTZDMyV1MjE5MCV1MjU2QyVBMQ__,inputs=NQ__)
Finally got use out of the fact that palindromizating `/` or `\` on the edge creates `X` (but this could be ~5 bytes less with a couple features I have had in mind for a while (e.g. that overlapping would overlap slashes too and palindomizating commands have the option to choose the overlap amount from the remainder of ceiling dividing))
Explanation:
```
.↔ push input ceiling-divided by 2 (. is required because SOGLs input is taken lazily)
╝ create a diagonal of that length
Ζ #ŗ replace spaces with hashes
.2%? if the input % 2 isn't 0
╬3 palindromize with 1 overlap
← stop program
έ [else] palindromize with 0 overlap
```
[Answer]
# [R](https://www.r-project.org/), 68 bytes
```
write(c("#","\\","/","X")[(d=diag(n<-scan()))+d[n:1,]*2+1],"",n,,"")
```
[Try it online!](https://tio.run/##K/r/v7wosyRVI1lDSVlJRykmBkjoA3GEkma0RoptSmZiukaejW5xcmKehqampnZKdJ6VoU6slpG2YayOkpJOng6Q1Pxv8h8A "R – Try It Online")
Reads `n` from stdin. Creates a matrix of indices `(d=diag(n))+d[n:1,]*2+1` to index into the vector of characters to print, which results in a vector of characters. `write` writes it as a matrix to `""` (stdout) with `n` columns and separator `""`.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 21 bytes
```
ＵＢ#Ｎν↗∕ν²×X﹪ν²‖ＢＯL﹪ν²
```
[Try it online!](https://tio.run/##RcqxCsIwEADQPV8RIsIFUgTdOnYTREtVcI3x2gbTNJyXgl8fF8X5PTdacrMNpZyRG@ueA805PkCtlBb7mDIf83RHgqhFSz4y1NfU@WFkIzcQjdzqH1z8hC9QN2Xk@itadNgHdNxkZqQ@vE8LUrAJ6sN/lbIr1RI@ "Charcoal – Try It Online") Verbose version.
[Answer]
# [MATL](https://github.com/lmendo/MATL), 14 bytes
```
'\/X#'iXytPE+)
```
[Try it online!](https://tio.run/##y00syfn/Xz1GP0JZPTOisiTAVVvz/39zAA "MATL – Try It Online")
Explanation: suppose the input is 3
```
'\/X#' push this character string.
i read in input. stack is ['\/X#';3]
Xy push nxn identity matrix.
stack is ['\/X#'; [1 0 0 ; 0 1 0 ; 0 0 1]]
tP duplicate and flip left-right
stack is ['\/X#'; [1 0 0 ; 0 1 0 ; 0 0 1];
[0 0 1 ; 0 1 0 ; 1 0 0]]
E+ double TOS and add top 2 stack elements
stack is ['\/X#'; [1 0 2 ; 0 3 0 ; 2 0 1]]
) index; 1-based modular, so
1 -> \, 2 -> /, 3 -> X, 0 -> #
implicit output.
```
[Answer]
# Javascript, 103 bytes
```
n=>{for(let i=n,j,s;i--;){s="";for(j=n;j--;)s+=i==j?n-j-1==j?"X":"\\":n-j-1==i?"/":"#";console.log(s)}}
```
[Try it online!](https://tio.run/##LclNCsIwEIbhvaco4ybBRqn/NIy9hotuSk1KhjKRprgpPXt0wM3DN@9Q9@lSP4X3bDi@XB7dXHgsMuNj8XFScgfkkspkgzFWLwkBrLwI2ZKktMOASA0bMpUMeEINbQv1v4QGDr@yBdtHTnF0@zEOKul1zV5VeuPVUTgJZ@EiXIWbcNf5Cw "JavaScript (Node.js) – Try It Online")
A more readable version with spaces and breaks added:
```
n => {
for (let i = n, j, s; i--;) {
s="";
for (j = n; j--;)
s += i == j
? n - j - 1 == j
? "X"
: "\\"
: n - j - 1 == i
? "/"
: "#";
console.log(s)
}
}
```
[Answer]
# [Husk](https://github.com/barbuz/Husk), 20 bytes
```
´Ṫ§o!"¦/X#"+=ȯD=←¹+ŀ
```
[Try it online!](https://tio.run/##ASgA1/9odXNr///CtOG5qsKnbyEiwqYvWCMiKz3Ir0Q94oaQwrkrxYD///81 "Husk – Try It Online")
[Answer]
# [V](https://github.com/DJMcMayhem/V), 24 bytes
```
Àé#ÀÄòr\jlò|òr/klòÇÜ/ãrX
```
[Try it online!](https://tio.run/##K/v//3DD4ZXKQKLl8KaimKycw5tqgAz9bCDjcPvhOfqHFxdF/P//3wwA "V – Try It Online")
[Answer]
# Mathematica, 114 bytes
```
(s=#;F[x_]:=DiagonalMatrix[Table[x,s]];z=F@"\\"+Reverse@F@"/"//. 0->"#";If[OddQ@s,z[[t=⌈s/2⌉,t]]="X"];Grid@z)&
```
[Answer]
# [Python 2](https://docs.python.org/2/), 133 bytes
```
def f(k,h="#"):s=[h*i+"\\"+h*(k-i*2-2)+"/"+i*h for i in range(k/2)];print"\n".join(s+k%2*[k/2*h+"X"+k/2*h]+[e[::-1]for e in s[::-1]])
```
[Try it online!](https://tio.run/##XcxBCsMgEIXhq8iUgjqxIa6KIfcoqItCtU4FDUk2Pb1tml137@fBN7@3VItu7REiizx3aYITCLNONklCcA4wSZ4VSa20QOgBSSYW68KIUWHLvTwDz70WfpwXKhu4ApdXpcJXzGct7feTCeEG@FsebbDGqMHvRtiN9Wgv2h87dFdhIidx0O0D "Python 2 – Try It Online")
A beautiful mess done on mobile :-). If you have golfing suggestions, you are welcome to edit in yourselves (and credit you!), because I will be sleeping :P.
[Answer]
# [Python 2](https://docs.python.org/2/), 122 bytes
```
def f(n):s='\\'+'#'*(n-2)+'/';return['x'][:n]if n<2else[s]+['#'+l+'#'for l in f(n-2)]+[s[::-1]]
print'\n'.join(f(input()))
```
[Try it online!](https://tio.run/##FYxNCgIhGIb3nUJo8WkyRUIba06i7lIy5FXUgTq946yfn/Lvnww1xtsHFjiEbitZS5LOdOFYlJB0o2f1fasw9CNnNFwMDC/lU/OmOWmmK9NRhFxZYhHHaaYTNaP1cnfuVGpEJwu6fnMEDzyibJ0LIcZ47A "Python 2 – Try It Online")
A recursive aproach
[Answer]
# [Perl 5](https://www.perl.org/), 81 bytes
```
for$i(0..($n=<>)-1){$_='#'x$n;s|.{$i}\K.|\\|;s%.(.{$i})$%/$1%;s%/%X% if!/\\/;say}
```
[Try it online!](https://tio.run/##K0gtyjH9/z8tv0glU8NAT09DJc/Wxk5T11CzWiXeVl1ZvUIlz7q4Rq9aJbM2xluvJiamxrpYVU8DLKCpoqqvYqgKFNBXjVBVyExT1I@J0bcuTqys/f/f9F9@QUlmfl7xf11fUz0DQwMA "Perl 5 – Try It Online")
[Answer]
## [Canvas](https://github.com/dzaima/Canvas), 15 [bytes](https://github.com/dzaima/Canvas/blob/master/files/chartable.md)
```
：：#×＊；＼：↔１１╋１１╋
```
[Try it online!](https://dzaima.github.io/Canvas/?u=JXVGRjFBJXVGRjFBJTIzJUQ3JXVGRjBBJXVGRjFCJXVGRjNDJXVGRjFBJXUyMTk0JXVGRjExJXVGRjExJXUyNTRCJXVGRjExJXVGRjExJXUyNTRC,i=NQ__)
could get it to 11 bytes if canvas's overlap function had a default setting but it doesn't so...
[Answer]
# Mathematica, 99 bytes
```
FromCharacterCode[(2#+Reverse@#+2)&@DiagonalMatrix[45~Table~#]/.{2->35,137->88}]~StringRiffle~"\n"&
```
This uses a somewhat different technique from the other Mathematica solution. Also, we should probably start calling it the Wolfram Language at some point.
] |
[Question]
[
**This question already has answers here**:
[Connect the pixels](/questions/93824/connect-the-pixels)
(13 answers)
Closed 6 years ago.
*Inspired by [Braille graphics](https://codegolf.stackexchange.com/q/140624/42963)*
Given a Boolean matrix (i.e., consisting of only `1`s and `0`s), output an ASCII-art-style Unicode representation of the closed-polygon shape created by the `1`s in the matrix, using the Unicode drawing characters `┌ ─ ┐ │ └ ┘` (code points `0x250c, 0x2500, 0x2510, 0x2502, 0x2514,` and `0x2518,` respectively, separated by spaces). Replace the `0`s with spaces, so you're left with just the line drawing. Output or return that drawing.
You won't have to handle invalid or ambiguous input - there will be only one unambiguous path of `1`s through the matrix. In other words, every `1` has exactly two cardinal neighbors that are `1`s, and two that are `0`s or out of bounds. Additionally, since the shape is a closed-polygon, this guarantees that the path is cyclical.
Examples:
```
[[1,1,1]
[1,0,1]
[1,1,1]]
┌─┐
│ │
└─┘
[[0,1,1,1,1,0],
[1,1,0,0,1,1],
[1,0,0,0,0,1],
[1,1,1,1,1,1]]
┌──┐
┌┘ └┐
│ │
└────┘
[[1,1,1,0,0]
[1,0,1,1,1]
[1,0,0,0,1]
[1,1,0,1,1]
[0,1,1,1,0]]
┌─┐
│ └─┐
│ │
└┐ ┌┘
└─┘
[[1,1,1,0]
[1,0,1,1]
[1,1,0,1]
[0,1,1,1]]
┌─┐
│ └┐
└┐ │
└─┘
```
* Leading or trailing newlines or whitespace are all optional, so long as the characters themselves line up correctly.
* Either a full program or a function are acceptable. If a function, you can return the output rather than printing it.
* If possible, please include a link to an online testing environment so other people can try out your code!
* [Standard loopholes](http://meta.codegolf.stackexchange.com/q/1061/42963) are forbidden.
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so all usual golfing rules apply, and the shortest code (in bytes) wins.
[Answer]
# Javascript (ES6), 125 bytes
```
a=>a.map((r,i)=>r.map((c,j)=>c&&"─ ┌└ ┐┘ |"[!(a[i-1]||0)[j]+!(a[i+1]||0)[j]*2+!r[j-1]*4+!r[j+1]*8-3]||" ").join``).join`
`
```
Example code snippet:
```
f=
a=>a.map((r,i)=>r.map((c,j)=>c&&"─ ┌└ ┐┘ |"[!(a[i-1]||0)[j]+!(a[i+1]||0)[j]*2+!r[j-1]*4+!r[j+1]*8-3]||" ").join``).join`
`
o.innerText=f([[1,1,1,0,0],
[1,0,1,1,1],
[1,0,0,0,1],
[1,1,0,1,1],
[0,1,1,1,0]])
```
```
<pre id=o>
```
] |
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
This question does not appear to be about code golf or coding challenges within the scope defined in the [help center](https://codegolf.stackexchange.com/help/on-topic).
Closed 6 years ago.
[Improve this question](/posts/136834/edit)
# BackStory
Given a square matrix of alphabets which contain English letters in arbitrary manner. While searching a word in it, you can go left to right horizontally, vertically downwards or diagonally towards left (both upwards and downwards).
You have to find the `number of matches of a given word` in the matrix.
For example, In the given square matrix `{A#A#K,A#S#K,A#K#K}`,[](https://i.stack.imgur.com/tgLyX.png)
The word `"ASK`" is matched four times in the input matrix. So the output will be 4.
# Input Format
You will be given two-dimensional string array and a string(Word to be searched) as arguments.
# Output Format
You need to return the Number of occurrences of the word in the matrix {an integer}.
# Sample Test Case1
Sample Input
```
2
2
A S
S T
AS
```
# Sample Output
2
# Sample Test Case 2
```
Sample Input
5
5
E D E E E
D I S K E
E S E E E
E C E E E
E E E E E
DISK
```
# Sample Output
1
# Explanation:
In this example, "`DISK`" is matched only one time in the input matrix. So the output will be `1`.
## Winning
Shortest code in 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/114407/edit).
Closed 6 years ago.
[Improve this question](/posts/114407/edit)
Many applications that depend on network resources (such as games connecting to game servers) do not allow the user to set a proxy. There are a lot of ways to force the usage of a proxy regardless, I personally have always been a fan of a **local SOCKS tunnel.**
## What's that?
Instead of connecting directly, an application on your local machine listens on a locally bound address and *relays* any connection to a fixed endpoint using a remote SOCKS proxy.
Example: Let our target be 11.22.33.44:5555, and our remote socks proxy be 99.88.77.66:5555. Our application listens on 127.0.0.1:5555. Our route now looks like this:
*connect to* **127.0.0.1:5555** - *relays via SOCKS proxy* > **99.88.77.66:5555** - *to* > **11.22.33.44:5555**
Your goal is to implement the local application relaying connections to the target.
## Input
Three address/port pairs representing the bind, proxy and target address.
* You may deviate from the order (but specify if you do).
* Address parsing is up to your language/tools of choice, but should at the very minimum support IPv4 (11.22.33.44).
* You may use builtin types of your language. (like `InetSocketAddress` in Java, `struct in_addr` in C, etc.)
## Output
No rules for output due to [networking](/questions/tagged/networking "show questions tagged 'networking'").
## Additional
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), shortest answer in bytes wins.
* [Standard rules](https://codegolf.meta.stackexchange.com/questions/2419/default-for-code-golf-program-function-or-snippet/2422) apply, [default loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) are forbidden.
* You do not have to support more than 1 connection. The program may terminate after the first connection finishes.
* Program behaviour under network failures is undefined; you may crash the entire program, reject the incoming connection, do whatever you want.
* You may assume the remote SOCKS proxy's version (4/4a/5).
* Using libraries/inbuilts/etc. is encouraged, but not required.
* Stay in input scope (f.e. don't proxy all connections on the machine).
[Answer]
# Kotlin, 240 bytes
This was fun and taught me some things I didn't know about Kotlin.
```
import java.net.*fun a(vararg p:InetSocketAddress){ServerSocket().run{bind(p[0])
accept().let{Socket(Proxy(Proxy.Type.SOCKS,p[1])).run{connect(p[2])
Thread{it.inputStream.copyTo(outputStream)}.start()
inputStream.copyTo(it.outputStream)}}}}
```
Tested locally with:
```
fun main(args: Array<String>) {
thread { a(InetSocketAddress(2000), InetSocketAddress(3000), InetSocketAddress(4000)) }
thread { Socket().connect(InetSocketAddress(2000)) }
ServerSocket(3000).accept().getInputStream().run { generateSequence { read() } }
.forEach { print("$it,") }
}
```
Prints `5,2,0,2,` which confirms an attempted SOCKS5 connection.
] |
[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/113007/edit).
Closed 6 years ago.
[Improve this question](/posts/113007/edit)
Not an interpreter. Arguably a compiler. But I'm talking about a transpiler.
It can be in any language, but it must return [js-valid arrow notation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions) code.
The [λ-calculus](https://en.wikipedia.org/wiki/Lambda_calculus) string would be passed as an argument to a function, or the whole program, and in some way the program would return/log/print the string with the js-notation.
Whitespace is not important, if it makes the writing easier.
Only accepted answers are with curry notation for output, not multiple parameters. The λ-calculus notation shorthand for multiple parameters must be considered.
All identifiers will be separated either by a (space), a `λ`, a `.` or `()` (parentheses). They can be more than a single character. Note that if the language has issues with keeping track of characters like `λ`, then you can cut yourself some slack and use `\`.
The transpiler doesn't have to evaluate the expression to simplify it, but as long as the statement is equivalent, I'll allow it. It won't gain any extra points.
All unneeded parenthesis can be taken out. `x=>x` is just as valid as `(x=>x)` which is just as valid as `((x)=>x)` or `(x)=>x`.
Using non arrow-function javascript features is disallowed, although if you come up with interesting hacks, they might be worth checking out, so feel free to ask if you have something creative.
Efficiency isn't really important, as long as vaguely practical, so answer with least amount of bytes wins
Examples:
```
λx.x -> (x)=>x
λx y.x(y) -> (x)=>(y)=>x(y)
λx.λy.x(y) -> (x)=>(y)=>x(y)
λs z.s(s z) -> (s)=>(z)=>s(s(z))
λfoo bar.foo bar -> (foo)=>(bar)=>foo(bar)
(λa b c.b c a) x y -> ((a)=>(b)=>(c)=>(b(c)(a)))(x)(y)
```
]
|
[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/109994/edit).
Closed 7 years ago.
[Improve this question](/posts/109994/edit)
## The challenge
Your task is to decode the first character in a UTF-8 byte sequence. The *input* is a byte array or a byte string holding a UTF-8 byte sequence.
If the (start of the) sequence is valid, the *output* is the Unicode code point of the first character in the sequence which is a number between 0 and 0x10FFFF. Your program or function can return a numeric data type or return or print a textual representation of the number in any base.
If the sequence is invalid, *your program must signal an error*. You can return a unique value that is outside the range of Unicode code points, throw an exception, or whatever.
The UTF-8 string must be decoded according to [RFC 3629](https://www.rfc-editor.org/rfc/rfc3629). Here's the UTF-8 syntax from the RFC:
```
UTF8-octets = *( UTF8-char )
UTF8-char = UTF8-1 / UTF8-2 / UTF8-3 / UTF8-4
UTF8-1 = %x00-7F
UTF8-2 = %xC2-DF UTF8-tail
UTF8-3 = %xE0 %xA0-BF UTF8-tail / %xE1-EC 2( UTF8-tail ) /
%xED %x80-9F UTF8-tail / %xEE-EF 2( UTF8-tail )
UTF8-4 = %xF0 %x90-BF 2( UTF8-tail ) / %xF1-F3 3( UTF8-tail ) /
%xF4 %x80-8F 2( UTF8-tail )
UTF8-tail = %x80-BF
```
Any byte sequence that doesn't match the syntax above must result in an error. Besides the more obvious cases of invalid input, this means:
* No overlong encodings.
* No code points above 0x10FFFF.
* No surrogates.
Trailing bytes after the first character are allowed and don't have to be checked for validity. Unexpected end of input must obviously result in an error but you can assume that the byte sequence isn't empty.
Zero-terminated strings are allowed. If you choose to work with zero-terminated strings, U+0000 can't be detected, so it's OK to only handle code points U+0001 to U+10FFFF. Otherwise, U+0000 must be handled.
## Test input
Here are some hex byte sequences that can be used as test input. The valid sequences may optionally be followed by any other bytes.
```
01 Valid, U+0001 START OF HEADING
41 Valid, U+0041 LATIN CAPITAL LETTER A
7F Valid, U+007F DELETE
C3 9F Valid, U+00DF LATIN SMALL LETTER SHARP S
E2 80 94 Valid, U+2014 EM DASH
F0 9F A4 98 Valid, U+1F918 SIGN OF THE HORNS
F4 8F BF BF Valid, U+10FFFF Noncharacter but valid
85 Invalid, starts with continuation byte
C0 80 Invalid, overlong two-byte sequence
C3 C0 Invalid continuation byte
D4 Invalid, unexpected end of input
E0 9F BF Invalid, overlong three-byte sequence
E3 82 Invalid, unexpected end of input
ED A2 93 Invalid, surrogate U+D893
F0 8A B2 A0 Invalid, overlong four-byte sequence
F1 B3 B8 Invalid, unexpected end of input
F2 80 B2 53 Invalid continuation byte
F4 93 81 B3 Invalid, code point above U+10FFFF
F5 Invalid start byte
FF Invalid start byte
```
## Rules
* Functions are allowed.
* **Using any UTF-8 decoding features of your programming language is not allowed.** You can't just call `ord` in Perl, for example.
* This is code golf. The shortest answer wins. No loopholes.
]
|
[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/102673/edit)
It's holiday season. A mall is empty except of air, money, and a very clever thief that is you.
The mall consists of n floors. Each floor can be represented as a rectangular 2D grid. All floors have the same 2D dimensions. You are somewhere inside the building. Your job, as a hard-working thief, is to collect c coins and then run to freedom through the exit door at the northwest corner cell of the first floor, in the minimum number of steps.
Each cell is either empty, a wall, a magic cell, or has a coin. You can move in the 4 compass directions as long as the cell you're moving to is not a wall. Moving from a cell to an adjacent cell takes 1 step. A magic cell can take you from the cell it's on to the corresponding one in another fixed floor (unless it's a wall), for no extra steps (other than the step you took to go to it). You can use it several times. Note that you can use the magic cell as an empty cell.
Floor representation: rectangular 2D grid of cells. Each cell contains a symbol or a character:
'.' represents an empty cell.
'!' represents your start position.
'S' represents a coin which you can take or ignore by passing through this cell. After a coin is taken, you can't retake it by moving through the cell again.
'\*' represents a wall which you can't pass.
a character between indicating this is a magic cell, and the character represents the floor the magic cell can take you to. First floor is a, second is b, .. etc.
Input
The input file consists of t (1 ≤ t ≤ 1024) test cases. The first line of each test case contains n, x, y (1 ≤ n, x, y ≤ 20) and c (0 ≤ c ≤ 8) - the number of floors, the dimensions of any floor, and the number of coins.
n grids follow, the ith grid represents the ith floor. For every grid you will read x lines, each contains y cells.
The total number of coins will not exceed 8.
Output
If you can't collect the c coins and run away print -1 otherwise print the minimum number of steps needed to complete your mission.
Example
input
```
7
1 1 1 0
!
2 1 3 1
.!b
.aS
2 1 4 1
.!.b
.aSS
2 1 4 1
.!.b
..SS
2 1 4 2
.!.b
Sa.S
2 1 4 2
.!.b
.a.S
2 1 4 2
S!.b
.a.S
```
output
```
0
3
5
-1
7
-1
5
```
Note
If we model each floor as a matrix indexed from (0, 0) to (x - 1, y - 1):
* To run away, you'd need to go cell (0, 0) in the first floor.
* A magic cell called 'e' on, for example, the 3rd floor in cell (2, 4) could take you to cell (2, 4) (unless it's a wall) on the 5th floor for no extra steps.
]
|
[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/102195/edit).
Closed 7 years ago.
[Improve this question](/posts/102195/edit)
Your goal is to create a program. It must take input indefinitely.
Here is a sample run (the `>` shows that the line is the output from the program)
```
2,6
> 0
5,6
> 0
7,5
> 0
2,7
> 1
```
Since 2 is connected to 6, which in turn is connected to 5 and then 7, 2 and 7 are hence connected.
```
5,2
> 1
...
```
### Clarifications
Whenever the user writes any two numbers (separated by any delimiter you prefer), the program must output whether they are connected or not. If they are not connected, the program must output a falsy value (0), however if the wires are connected, the program must output a true value (1).
"We are to interpret the pair p-q as meaning “p is connected to q.” We assume the relation “is
connected to” to be transitive: If p is connected to q, and q is connected
to r, then p is connected to r."
The input must be separated from the output by a newline `\n`
The input will always be integers in base ten and never floats.
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the program with the shortest bytecount wins!
]
|
[Question]
[
Write the shortest possible program that draws a Bresenham line in ASCII art. Your program should take two integers `x` and `y` (command line or stdin, your choice) and draw an ASCII line which starts in the upper left and goes right `x` units and down `y` units. You must use `_` and `\` characters and place them in the correct location according to [Bresenham's](http://en.wikipedia.org/wiki/Bresenham%27s_line_algorithm) algorithm.
You may assume `x >= y`, so no vertical segments are required.
Note that because you're using the `_` character, for a line with `y=3` you will likely need to output 4 lines of text (and you may emit a leading blank line when it isn't necessary).
examples:
```
11 3
_
\___
\___
\_
11 1
_____
\_____
5 4
\
\_
\
\
```
For points which are exactly halfway you may choose either rounding:
```
10 1
____
\_____
or
_____
\____
```
[Answer]
# Perl, 74
```
/ /;print int(.5+$_*$'/$`)>int(.5+--$_*$'/$`)?$/.$"x$_.'\\':'_'for 1..$`
```
Run with `-n` option (counted in code size).
```
$ perl -n bresenham.pl <<<'11 3'
_
\___
\___
\_
$ perl -n bresenham.pl <<<'11 1'
_____
\_____
$ perl -n bresenham.pl <<<'5 4'
\
\_
\
\
$ perl -n bresenham.pl <<<'10 1'
____
\_____
```
[Answer]
# C ~~136~~ 123 Characters
```
z,x,y,i,f;main(){for(scanf("%d%d",&x,&y);i<=x;i++){f=f?printf("_"):1;z+=y;if(2*z>=x&&i<x)f=0,z-=x,printf("\n%*c",i+1,92);}}
```
[Answer]
# Delphi, 109 bytes
Quite small if you ask me :
```
var x,y,i:Word;begin Read(x,y);for i:=1to(x)do if(i*y+x div 2)mod x<y then Write(^J,'\':i)else Write('_')end.
```
The 2 integers are read from the command line.
The newline is written by the seldomly used `^J` syntax (meaning LineFeed), the following '`\`' character is indented using the little-known syntax :`Write(string:width)`.
It's a pitty Delphi `div` for integer-divide (instead of just `\`). Ah well...
[Answer]
# [APL (Dyalog Classic)](https://www.dyalog.com/), 39 bytes
```
{⍉↑(-1++\a)↑¨'_\'[a←-2-/⌊.5+⍵×⍺÷⍨⍳1+⍺]}
```
[Try it online!](https://tio.run/##bU29CsIwEN59im5RSqzxZ/FVjIRQqRQCldZFpJNSqBqxg7g7uYsIHe2b3IvUq7VWwQuE776/kzNFJwupvCm1lQwC185hf3Q9iA6d3MF/CTqGKGlSZppcthA@LkRwMpIo0i61YLdpD0zQt@wEOs3uoC@grwyZdBzm@bzsuEF89hHCZuVYKA2JI11FEKHmw3aNV1H2wwZjRg9DCRHGZwg@LoSot2JKptpKhhR5VubF34RAz8DoGy8PCrw@UBl5FeBY1/mq@2l7lz0B "APL (Dyalog Classic) – Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 22 bytes
```
Ｆ…·¹θ⎇‹﹪⁺×ιη⌊∕θ²θη¶\¦_
```
It took a while to figure out the right formula, but it now works! Credit to the Delphi answer.
Link is to verbose version of code.
[Try it online!](https://tio.run/##JctBCsIwEEDRq0hWMzBdKHoAQQqCbqQ7IxKT0Q6kCU1ooKePEXcPPt@OJtlofK19THAO1i9ZCt9M@DBsaUbcDJyCSStcOGe4Rrf4CEfnYJCJMwiNSL2P7T5JEccw0w4R2/orSgetFamnwlrvB9o/atcVTq@Yucnx3/Jevw "Charcoal – Try It Online")
] |
[Question]
[
[SageMath](http://www.sagemath.org/) is an open-source mathematics software system, built on Python 2. Its extensive math library support makes it a strong choice for golfing in math-based challenges.
What tips do you have for golfing in SageMath? One tip per answer, please. Tips should be specifically for SageMath, and not general golfing tips ("remove unnecessary whitespace"). Tips that apply to Python in general should go in the [Python tips post](https://codegolf.stackexchange.com/q/54/45941).
]
|
[Question]
[
# Background
The official currency of the imaginary nation of Golfenistan is the *foo*, and there are only three kinds of coins in circulation: 3 foos, 7 foos and 8 foos.
One can see that it's not possible to pay certain amounts, like 4 foos, using these coins.
Nevertheless, all large enough amounts can be formed.
Your job is to find the largest amount that can't be formed with the coins (5 foos in this case), which is known as the [coin problem](https://en.wikipedia.org/wiki/Coin_problem).
# Input
Your input is a list `L = [n1, n2, ..., nk]` of positive integers, representing the values of coins in circulation.
Two things are guaranteed about it:
* The GCD of the elements of `L` is 1.
* `L` does not contain the number 1.
It may be unsorted and/or contain duplicates (think special edition coins).
# Output
Since the GCD of `L` is 1, every large enough integer `m` can be expressed as a non-negative linear combination of its elements; in other words, we have
```
m = a1*n1 + a2*n2 + ... + ak*nk
```
for some integers `ai ≥ 0`.
Your output is the largest integer that *cannot* be expressed in this form.
As a hint, it is known that the output is always less than `(n1 - 1)*(nk - 1)`, if `n1` and `nk` are the maximal and minimal elements of `L` ([reference](http://www.cis.upenn.edu/~cis511/Frobenius-number.pdf)).
# Rules
You can write a full program or a function.
The lowest byte count wins, and standard loopholes are disallowed.
If your language has a built-in operation for this, you may not use it.
There are no requirements for time or memory efficiency, except that you should be able to evaluate the test cases before posting your answer.
After I posted this challenge, user @vihan pointed out that Stack Overflow has an [exact duplicate](https://stackoverflow.com/questions/3465392/code-golf-frobenius-number).
Based on [this Meta discussion](http://meta.codegolf.stackexchange.com/questions/6896/duplicates-on-other-se-sites), this challenge will not be deleted as a duplicate; however, I ask that all answers based on those of the SO version should cite the originals, be given the Community Wiki status, and be deleted if the original author wishes to post their answer here.
# Test Cases
```
[3, 7, 8] -> 5
[25, 10, 16] -> 79
[11, 12, 13, 14, 13, 14] -> 43
[101, 10] -> 899
[101, 10, 899] -> 889
[101, 10, 11] -> 89
[30, 105, 70, 42] -> 383
[2, 51, 6] -> 49
```
[Answer]
# Perl, ~~60~~ ~~54~~ 51 bytes
50 bytes code + 1 bytes command line
```
$.*=$_,$r.=1x$_."|"}{$_=$.while(1x$.--)=~/^($r)+$/
```
The basic approach is to let the regex engine do the hard work with string matching. For example, it will construct a regex similar to `^(.{3})*(.{7})*(.{8})*$` and match against a string of length `n` where `n` descends from the product of the inputs until it fails to match.
Note that this will become exponentially slow as the number of arguments increases.
Usage:
Arguments are read in from STDIN (new line separated), for example:
```
printf "101\n10" | perl -p entry.pl
```
[Answer]
# Pyth, 23 bytes
```
ef!fqTs.b*NYQY^UTlQS*FQ
```
It's very slow, as it checks all values up to the product of all the coins. Here's a version that is almost identical, but 1) reduces the set of coins to those not divisible by each other and 2) only checks values up to `(max(coins) - 1) * (min(coins) - 1)` (47 bytes):
```
=Qu?.A<LiHdG+GHGQYef!fqTs.b*NYQY^UTlQS*thSQteSQ
```
## Explanation
```
S range 1 to
*FQ product of input
f filter by
UT range 0 to T
^ lQ cartesian power by number of coins
f filter by
s.b*NYQY sum of coin values * amounts
qT equals desired number T
! nothing matching that filter
e take last (highest) element
```
[Answer]
# [R](https://www.r-project.org/), 84 78 72 bytes
For an arbitrary entry of coprimes, \$a\_1, a\_2,\ldots\$, [Frobenius' amount](https://en.wikipedia.org/wiki/Coin_problem) is given by
```
a=scan();max((1:(b<-min(a)*max(a)))[-colSums(combn(outer(a,0:b),sum(!!a)))])
```
[Try it online!](https://tio.run/##FcpBCoAgEAXQq@TuTxhomyDqFC2jhUqC0ChUA93ecPt4d41rjZLDm0qGI3YfYGf4ZeDUoG/iiGgfQrk24QehsM8o8p43nDazJ/0IQ6nWDqoRAXbSnTUjUf0B "R – Try It Online")
since it is always smaller than the product of the extreme \$a\_i\$'s. It is then a matter of combining all possible combinations (and more) within that range. Thanks to Cole Beck for suggesting `outer` with no "\*" and `colSums` rather than `apply(...,2,sum)'.
A faster but longer (by two bytes) version only considers `max(a)`:
```
a=scan();max((1:(min(a)*(b<-max(a))))[-colSums(combn(outer(a,0:b),sum(!!a)))])
```
A slightly shorter version (72 bytes) that most often takes too log or too much space to run on [Try it online](https://tio.run/##FctBCsIwEAXQu3T1fxmh050FTxKyGEOjQpOUmkA9fdT14x093npsOdRXyTAmOwFdYE79aG72pLvYvm8fhJLuGaXV9YDJtPxVhnGgbGt@1OdvU2Z5t0TPHhGgV9FJyf4F) is
```
a=scan();max((1:(b<-prod(a)))[-colSums(combn(outer(a,0:b),sum(!!a)))])
```
[Answer]
# Python2, 188 187 bytes
```
def g(L):
M=max(L);i=r=0;s=[0]*M;l=[1]+s[1:]
while 1:
if any(all((l+l)[o:o+min(L)])for o in range(M)):return~-s[r]*M+r
if any(l[(i-a)%M]for a in L):l[i]=1
else:r=i
s[i]+=1;i=(i+1)%M
```
The second indentation is rendered as 4 spaces on SO, those should be tabs.
Actually a 'fast' solution, not bruteforce, uses 'Wilf's Method' as described [here](http://www.math.univ-montp2.fr/%7Eramirez/Tenerif1.pdf).
[Answer]
# Javascript ES6, ~~120~~ ~~130~~ ~~126~~ ~~128~~ ~~127~~ 125 chars
```
f=a=>`${r=[1|a.sort((a,b)=>a-b)]}`.repeat(a[0]*a[a.length-1]).replace(/./g,(x,q)=>r[q]|a.map(x=>r[q+x]|=r[q])).lastIndexOf(0)
```
Alternative 126 chars version:
```
f=a=>{r=[1];a.sort((a,b)=>a-b);for(q=0;q<a[0]*a[a.length-1];++q)r[q]?a.map(x=>r[q+x]=1):r[q]=0;return r.join``.lastIndexOf(0)}
```
Test:
```
"[3, 7, 8] -> 5\n\
[25, 10, 16] -> 79\n\
[11, 12, 13, 14, 13, 14] -> 43\n\
[101, 10] -> 899\n\
[101, 10, 899] -> 889\n\
[101, 10, 11] -> 89\n\
[30, 105, 70, 42] -> 383\n\
[2, 51, 6] -> 49".replace(/(\[.*?\]) -> (\d+)/g, function (m, t, r) {
return f(JSON.parse(t)) == r
})
```
[Answer]
# [Ruby](https://ruby-doc.org/), 108 bytes
```
->a{b=[0];m=a.min
(1..1.0/0).map{|n|c=p
a.map{|x|c|=(b!=b-[n-x])}
c&& b<<=n
return n-m if b[-m]&&b[-m]>n-m}}
```
[Try it online!](https://tio.run/##dc/daoMwFADg@zzFGQNpwWSJP1Vp44uEXBhpwYtk4ia0VJ/dnVi2EdcFQv6@c3LOMJrbchnezdl144dcaN3cjVRcH61smO0c2QnGBONvfM9s098nN7WyJ83jcJ3aSe7MizRUOXrV@5m0UQTmdJKODOfPcXDgqIXuAkZRq6NoXWq8m@elh5@flUpjKGIotYbNeJU15CSwSR6D4DgPG@5tUYVYCIQJTvxBZN8rBnqcpRvMvebPqyir6qmO/UsQsuryPy1EmP@RO8Spdxz7LHCTJb8BHqflpmxsL8fkhz91rz1Wyxc "Ruby – Try It Online")
# Explanation
```
->a{ input list
b=[0]; list of representable integers
m=a.min minimum input
(1..1.0/0).map{|n| n in range 1..
c=p c = false
a.map{|x|c|=(b!=b-[n-x])} check if n goes in b
c&& b<<=n put n in b
return n-m if b[-m]&&b[-m]>n-m}} return if m values in a row
```
] |
[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/84360/edit).
Closed 7 years ago.
[Improve this question](/posts/84360/edit)
Write some code to do the following:
1. Take as its input a signed integer in either signed decimal or signed octal
(explained below)
2. If the number is decimal convert it to octal. If it's octal, convert it to decimal
3. Output the number!
Instead of starting with a `0`, negative octal numbers will start with a `Z` (capital zed).
In the same way that -1 is commonly encoded in binary as all `1`s, in signed octal it is encoded as all `7`s. -2 is all `7`s except for the final digit which is `6`, and so on.
Your code must accept leading `0`s, or `7`s (after the initial `Z` in octal) but must not output leading `0`s for decimal or non-negative octal, with the exception of a single `0` to indicate octal format, and must not output leading `7`s in the case of negative octal. `0` is valid as an entire number in both decimal and octal and is the only number to have an identical representation in both. Decimal numbers must not have any leading zeros and must be interpreted as octal if they do (i.e. `08` should be interpreted as neither decimal nor octal). Note that `0`s immediately after the `Z` are significant and must not be truncated. `Z` is shorthand for an infinite number of `7`s. You may assume that the input will always be valid and not check for it in your code.
```
Input : Output
-1 : Z
-10: Z66
-5: Z3
10: 012
-30000: Z05320
-10000: Z54360
0 : 0
01234: 668
Z1234: -3428
Z77777: -1
00777: 511
Z6000: -1024
```
A table of the first few positive and negative signed octal numbers:
```
+ve -ve
0 0
01 Z
02 Z6
03 Z5
04 Z4
05 Z3
06 Z2
07 Z1
010 Z0
011 Z67
012 Z66
```
Make it small!
]
|
[Question]
[
Your goal is to determine whether a given 2D point X lies within the area of the triangle with given vertices A,B,C.
Write a function that takes in the coordinates of the test point X and the three triangle vertices (so that's 8 coordinates total) and returns True if the point lies inside that triangle, and False if it lies outside.
Don't worry about edge cases. If the point lies on the boundary of the triangle (edge or vertex) or the triangle is actually a line segment, your code can do whatever, including crashing. Also don't worry about numerical stability or floating-point precision.
Your code must be a named function. Code snippets will not be accepted.
Fewest characters wins.
**Input:**
Eight real numbers representing coordinates. The numbers will lie in the range `(-1,1)`.
The exact input format is flexible. You could, for example, take in eight numbers, a list of eight numbers, a list of four points each given by a tuple, a 2\*4 matrix, four complex numbers, two lists of the x-coordinates and y-coordinates, and so on.
The input needs to just be the numbers in some container, with no additional data. You can't use the input to do any preprocessing, nor may you require any constraints on the input, such as requiring the points be given in ascending y coordinate. Your input must allow any eight coordinates (though your code can behave arbitrarily in the edge cases mentioned earlier).
Please state your input format.
**Output:**
Either the corresponding Boolean `True`/`False`, the corresponding number `1`/`0`, or the analogues in your language.
**Test cases**
The inputs are given a list `[X,A,B,C]` of four tuples, the test point first, then the three triangle vertices. I've grouped them into those whose outputs should be `True` and those that should be `False`.
`True` instances:
```
[(-0.31961, -0.12646), (0.38478, 0.37419), (-0.30613, -0.59754), (-0.85548, 0.6633)]
[(-0.87427, -0.00831), (0.78829, 0.60409), (-0.90904, -0.13856), (-0.80685, 0.48468)]
[(0.28997, -0.03668), (-0.28362, 0.42831), (0.39332, -0.07474), (-0.48694, -0.10497)]
[(-0.07783, 0.04415), (-0.34355, -0.07161), (0.59105, -0.93145), (0.29402, 0.90334)]
[(0.36107, 0.05389), (0.27103, 0.47754), (-0.00341, -0.79472), (0.82549, -0.29028)]
[(-0.01655, -0.20437), (-0.36194, -0.90281), (-0.26515, -0.4172), (0.36181, 0.51683)]
[(-0.12198, -0.45897), (-0.35128, -0.85405), (0.84566, 0.99364), (0.13767, 0.78618)]
[(-0.03847, -0.81531), (-0.18704, -0.33282), (-0.95717, -0.6337), (0.10976, -0.88374)]
[(0.07904, -0.06245), (0.95181, -0.84223), (-0.75583, -0.34406), (0.16785, 0.87519)]
[(-0.33485, 0.53875), (-0.25173, 0.51317), (-0.62441, -0.90698), (-0.47925, 0.74832)]
```
`False` instances:
```
[(-0.99103, 0.43842), (0.78128, -0.10985), (-0.84714, -0.20558), (-0.08925, -0.78608)]
[(0.15087, -0.56212), (-0.87374, -0.3787), (0.86403, 0.60374), (0.01392, 0.84362)]
[(0.1114, 0.66496), (-0.92633, 0.27408), (0.92439, 0.43692), (0.8298, -0.29647)]
[(0.87786, -0.8594), (-0.42283, -0.97999), (0.58659, -0.327), (-0.22656, 0.80896)]
[(0.43525, -0.8923), (0.86119, 0.78278), (-0.01348, 0.98093), (-0.56244, -0.75129)]
[(-0.73365, 0.28332), (0.63263, 0.17177), (-0.38398, -0.43497), (-0.31123, 0.73168)]
[(-0.57694, -0.87713), (-0.93622, 0.89397), (0.93117, 0.40775), (0.2323, -0.30718)]
[(0.91059, 0.75966), (0.60118, 0.73186), (0.32178, 0.88296), (-0.90087, -0.26367)]
[(0.3463, -0.89397), (0.99108, 0.13557), (0.50122, -0.8724), (0.43385, 0.00167)]
[(0.88121, 0.36469), (-0.29829, 0.21429), (0.31395, 0.2734), (0.43267, -0.78192)]
```
[Answer]
# Javascript / ECMAScript 6, 161 159 158 / 152
Javascript:
```
function $(t,r,i,a,n,g,l,e){b=(-g*l+a*(-n+l)+i*(g-e)+n*e)/2;c=b<0?-1:1;d=(a*l-i*e+(e-a)*t+(i-l)*r)*c;f=(i*g-a*n+(a-g)*t+(n-i)*r)*c;return d>0&&f>0&&d+f<2*b*c}
```
ECMAScript 6 version (thanks m.buettner, saves 6 characters)
```
$=(t,r,i,a,n,g,l,e)=>{b=(-g*l+a*(-n+l)+i*(g-e)+n*e)/2;c=b<0?-1:1;d=(a*l-i*e+(e-a)*t+(i-l)*r)*c;f=(i*g-a*n+(a-g)*t+(n-i)*r)*c;return d>0&&f>0&&d+f<2*b*c}
```
Call it as such (returns `true` or `false`):
```
$(pointX, pointY, v1X, v1Y, v2X, v2Y, v3X, v3Y);
```
Uses some fancy [barycentric coordinate math](http://en.wikipedia.org/wiki/Barycentric_coordinates_%28mathematics%29) based on code from [this answer](https://stackoverflow.com/a/2049712/863470). An ungolfed version for your reading enjoyment follows:
```
function $ (pointX, pointY, v1X, v1Y, v2X, v2Y, v3X, v3Y) {
var A = (-v2Y * v3X + v1Y * (-v2X + v3X) + v1X * (v2Y - v3Y) + v2X * v3Y) / 2;
var sign = A < 0 ? -1 : 1;
var s = (v1Y * v3X - v1X * v3Y + (v3Y - v1Y) * pointX + (v1X - v3X) * pointY) * sign;
var t = (v1X * v2Y - v1Y * v2X + (v1Y - v2Y) * pointX + (v2X - v1X) * pointY) * sign;
return s > 0 && t > 0 && s + t < 2 * A * sign;
}
```
[Answer]
## Python 2.7 ~~128~~ ~~127~~ ~~117~~ ~~110~~ ~~109~~ ~~103~~ ~~99~~ ~~95~~ ~~94~~ ~~91~~ 90
My first code-golf attempt!
## Code
```
f=lambda x,y,t:sum(a*y+c*b+d*x<d*a+c*y+b*x for i in(0,1,2)for a,b,c,d in[t[i-1]+t[i]])%3<1
```
Takes as input (x,y,t) where (x,y) is the point we're checking and t is a triangle t = ((x1,y1),(x2,y2),(x3,y3)).
## Explanation
I'm calculating the determinants of the matrices
```
| 1 x1 y1 | | 1 x2 y2 | | 1 x3 y3 |
| 1 x2 y2 | , | 1 x3 y3 | , | 1 x1 y1 | .
| 1 x y | | 1 x y | | 1 x y |
```
These determinants represent the signed distances from the sides of the triangle to the point (x,y). If they all have the same sign, then the point is on the same side of every line and is thus contained in the triangle.
In the code above, `a*y+c*b+d*x-d*a-c*y-b*x` is a determinant of one of these matrices.
I'm using the fact that `True+True+True==3` and `False+False+False==0` to determine if these determinants all have the same sign.
I make use of Python's negative list indices by using `t[-1]` instead of `t[(i+1)%3]`.
Thanks Peter for the idea to use `s%3<1` instead of `s in(0,3)` to check if s is either 0 or 3!
## Sagemath Version
Not really a different solution so I'm including it in this answer, a sagemath solution using **80** characters:
```
f=lambda p,t,o=[1]:sum([det(Matrix([o+t[i-1],o+t[i],o+p]))<0for i in 0,1,2])%3<1
```
where `p=[x,y]`, and `t=[[x1,y1],[x2,y2],[x3,y3]]`
[Answer]
## Mathematica, 67 bytes
```
f=Equal@@({#2,-#}&@@(#-#2).(x-#)>0&@@@Partition[x=#;#2,2,1,{1,1}])&
```
The function takes two arguments, the point `X` and a list of points `{A,B,C}`, which are referred to as `#` and `#2` respectively. That is if you call
```
f[X,{A,B,C}]
```
then you'll get `#` as `X` and `#2` as `{A,B,C}`. (Note that there are two other anonymous functions nested inside the code - `#` and `#2` have a different meaning within those.)
Here is an explanation of the function itself:
```
x=#;#2 & (* Save X into a variable x, but evaluate to {A,B,C}. *)
Partition[x=#;#2,2,1,{1,1}] & (* Get a cyclic list of pairs {{A,B},{B,C},{C,B}}. *)
( &@@@Partition[x=#;#2,2,1,{1,1}])& (* Define an anonymous function and apply it to each
of the above pairs. The two elements are referred
to as # and #2. *)
( (#-#2) &@@@Partition[x=#;#2,2,1,{1,1}])& (* Subtract the two points. For a pair of vertices
this yields a vector corresponding to the edge
between them. *)
{#2,-#}& (* An anonymous function that takes two values,
reverses them, inverts the sign of one of them
and puts them into a list. *)
({#2,-#}&@@(#-#2) &@@@Partition[x=#;#2,2,1,{1,1}])& (* Applied to the edge, this yields its normal. *)
({#2,-#}&@@(#-#2).(x-#) &@@@Partition[x=#;#2,2,1,{1,1}])& (* Take the scalar product of that normal with a
vector from a vertex to x. This is projection of
this vector onto that normal and hence the SIGNED
distance of x from the edge. *)
({#2,-#}&@@(#-#2).(x-#)>0&@@@Partition[x=#;#2,2,1,{1,1}])& (* Check the sign of that distance, the exact mapping
between (left, right) and (True, False) is
irrelevant, as long as it's consistent. *)
Equal@@({#2,-#}&@@(#-#2).(x-#)>0&@@@Partition[x=#;#2,2,1,{1,1}])& (* Check if all signs are equal - that is, if point X
lies on the same side of all edges. This is
equivalent to check that the point is inside the
triangle. *)
```
Note that this function will actually work for *any* convex n-gon as long as its vertices are given in either clockwise or counter-clockwise order.
[Answer]
# CJam, ~~66~~ ~~63~~ ~~59~~ ~~52~~ ~~46~~ ~~34~~ ~~32~~ ~~31~~ ~~30~~ 28 characters
```
"Ă䒟损崙㩴ァ椟饃꿾藭鑭蘁"2G#b131b:c~
```
After transforming the Unicode string, the following code (**33 bytes**) gets evaluated:
```
{2*2/\f{f{+~@-@@-}~@@*@@*>})-!}:T
```
Expects `X [A B C]` as input, where each point is of the form `[double double]`. Output is 1 or 0.
[Try it online.](http://cjam.aditsu.net/ "CJam interpreter")
A big thank you goes to [user23013](https://codegolf.stackexchange.com/u/25180) for saving 6 characters (13 bytes of uncompressed code)!
### Test cases
```
$ cat triangle.cjam
"Ă䒟损崙㩴ァ椟饃꿾藭鑭蘁"2G#b131b:c~
[
[-0.31961 -0.12646] [ [0.38478 0.37419] [-0.30613 -0.59754] [-0.85548 0.6633] ] T
[-0.87427 -0.00831] [ [0.78829 0.60409] [-0.90904 -0.13856] [-0.80685 0.48468] ] T
[0.28997 -0.03668] [ [-0.28362 0.42831] [0.39332 -0.07474] [-0.48694 -0.10497] ] T
[-0.07783 0.04415] [ [-0.34355 -0.07161] [0.59105 -0.93145] [0.29402 0.90334] ] T
[0.36107 0.05389] [ [0.27103 0.47754] [-0.00341 -0.79472] [0.82549 -0.29028] ] T
[-0.01655 -0.20437] [ [-0.36194 -0.90281] [-0.26515 -0.4172] [0.36181 0.51683] ] T
[-0.12198 -0.45897] [ [-0.35128 -0.85405] [0.84566 0.99364] [0.13767 0.78618] ] T
[-0.03847 -0.81531] [ [-0.18704 -0.33282] [-0.95717 -0.6337] [0.10976 -0.88374] ] T
[0.07904 -0.06245] [ [0.95181 -0.84223] [-0.75583 -0.34406] [0.16785 0.87519] ] T
[-0.33485 0.53875] [ [-0.25173 0.51317] [-0.62441 -0.90698] [-0.47925 0.74832] ] T
[-0.99103 0.43842] [ [0.78128 -0.10985] [-0.84714 -0.20558] [-0.08925 -0.78608] ] T
[0.15087 -0.56212] [ [-0.87374 -0.3787] [0.86403 0.60374] [0.01392 0.84362] ] T
[0.1114 0.66496] [ [-0.92633 0.27408] [0.92439 0.43692] [0.8298 -0.29647] ] T
[0.87786 -0.8594] [ [-0.42283 -0.97999] [0.58659 -0.327] [-0.22656 0.80896] ] T
[0.43525 -0.8923] [ [0.86119 0.78278] [-0.01348 0.98093] [-0.56244 -0.75129] ] T
[-0.73365 0.28332] [ [0.63263 0.17177] [-0.38398 -0.43497] [-0.31123 0.73168] ] T
[-0.57694 -0.87713] [ [-0.93622 0.89397] [0.93117 0.40775] [0.2323 -0.30718] ] T
[0.91059 0.75966] [ [0.60118 0.73186] [0.32178 0.88296] [-0.90087 -0.26367] ] T
[0.3463 -0.89397] [ [0.99108 0.13557] [0.50122 -0.8724] [0.43385 0.00167] ] T
[0.88121 0.36469] [ [-0.29829 0.21429] [0.31395 0.2734] [0.43267 -0.78192] ] T
]p;
$ cjam triangle.cjam
[1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0]
```
[Answer]
# C – 156 bytes
Input are array of 3 floats in X, 3 floats in Y and separate x and y for the test point. Bonus: handles all edge cases!
```
int f(float*X,float*Y,float x,float y){int i,j,c=0;for(i=0,j=2;i<3;j=i++)if(((Y[i]>y)!=(Y[j]>y))&&(x<(X[j]-X[i])*(y-Y[i])/(Y[j]-Y[i])+X[i]))c=!c;return c;}
```
Adapted from PNPOLY.
[Answer]
# [Pyth 1.0.5](https://github.com/isaacg1/pyth/blob/master/pyth.py), 57 54 51
```
DgYb=Z0J'bWbK;bDiHNR*-'H'K-@N1@K1~Z>iYJiJY=JK)R!%Z3
```
Defines the function g, which takes two inputs: the test point, and then the list of the vertices of the triangle. Outputs `True` and `False`. Note: Destroys the input, specifically b, the list of the vertices of the triangle.
Try it [here](http://ideone.com/fork/aPbXH9).
The last few characters, `gvwvw` call the function with a test case on the next two lines.
Based on [this](https://stackoverflow.com/questions/2049582/how-to-determine-a-point-in-a-triangle) algorithm
Explanation:
```
DgYb Define g(Y,b):
=Z0 Z=0
J'b J=b[0] (No = is needed because j is special).
Wb While len(b)>0: (While b:)
K;b K=b.pop()
DiHN Define i(H,N):
R*-'H'K-@N1@K1 Return half of the linked equation.
~ZiYJiJY Z+=i(Y,J)>i(J,Y)
=JK J=K
) Wend
R!%Z3 return not Z%3==0 (True iff Z == 0 or 3)
```
The CJam - Pyth war rages on!
[Answer]
# J 64 45 (42 without assignment)
```
c=:*./@(>:&0)@({.(,(1-+/))@%.|:@}.)@(}:-"1{:)
```
The assignment is not necessary for the thing to be a function, so unsure whether to count it or not.
Taking advantage of the flexible input: I'd like to have an array of (1 + number of vertices) x (dimensionality of the space).
Hoping to score some extra points here ... : This thing works for any dimension of simplex, not just triangles in a plane, but also a 3 sided pyramid in 3d space and so on. It also works when the number of vertices of the simplex is smaller than (n+1), then it computes whether the projection of the point onto the simplex is inside or not.
It converts to [barycentric coordinates](http://en.wikipedia.org/wiki/Barycentric_coordinate_system), then checks for negative ones, indicating the point is outside. Do mind J uses \_ for negative
```
NB. example in triangle
D =: 4 2 $ 1 1 0 0 3 0 0 2 NB. 4 rows , x first, then the vertices of the triangle
NB. subtract last vertex coordinates from the rest and drop reference node
n=: (}:-"1{:)
NB. preprocessed to barycentric coordinates
bar=: {. (, 1 - +/)@%. |:@}.
NB. all positive
ap =: *./@(>:&0)
insided =: ap@bar@n
inside D
1
```
A run on the given examples:
```
true =: 0 : 0
[(-0.31961, -0.12646), (0.38478, 0.37419), (-0.30613, -0.59754), (-0.85548, 0.6633)]
[(-0.87427, -0.00831), (0.78829, 0.60409), (-0.90904, -0.13856), (-0.80685, 0.48468)]
[(0.28997, -0.03668), (-0.28362, 0.42831), (0.39332, -0.07474), (-0.48694, -0.10497)]
[(-0.07783, 0.04415), (-0.34355, -0.07161), (0.59105, -0.93145), (0.29402, 0.90334)]
[(0.36107, 0.05389), (0.27103, 0.47754), (-0.00341, -0.79472), (0.82549, -0.29028)]
[(-0.01655, -0.20437), (-0.36194, -0.90281), (-0.26515, -0.4172), (0.36181, 0.51683)]
[(-0.12198, -0.45897), (-0.35128, -0.85405), (0.84566, 0.99364), (0.13767, 0.78618)]
[(-0.03847, -0.81531), (-0.18704, -0.33282), (-0.95717, -0.6337), (0.10976, -0.88374)]
[(0.07904, -0.06245), (0.95181, -0.84223), (-0.75583, -0.34406), (0.16785, 0.87519)]
[(-0.33485, 0.53875), (-0.25173, 0.51317), (-0.62441, -0.90698), (-0.47925, 0.74832)]
)
false =: 0 : 0
[(-0.99103, 0.43842), (0.78128, -0.10985), (-0.84714, -0.20558), (-0.08925, -0.78608)]
[(0.15087, -0.56212), (-0.87374, -0.3787), (0.86403, 0.60374), (0.01392, 0.84362)]
[(0.1114, 0.66496), (-0.92633, 0.27408), (0.92439, 0.43692), (0.8298, -0.29647)]
[(0.87786, -0.8594), (-0.42283, -0.97999), (0.58659, -0.327), (-0.22656, 0.80896)]
[(0.43525, -0.8923), (0.86119, 0.78278), (-0.01348, 0.98093), (-0.56244, -0.75129)]
[(-0.73365, 0.28332), (0.63263, 0.17177), (-0.38398, -0.43497), (-0.31123, 0.73168)]
[(-0.57694, -0.87713), (-0.93622, 0.89397), (0.93117, 0.40775), (0.2323, -0.30718)]
[(0.91059, 0.75966), (0.60118, 0.73186), (0.32178, 0.88296), (-0.90087, -0.26367)]
[(0.3463, -0.89397), (0.99108, 0.13557), (0.50122, -0.8724), (0.43385, 0.00167)]
[(0.88121, 0.36469), (-0.29829, 0.21429), (0.31395, 0.2734), (0.43267, -0.78192)]
)
NB. replace - by _ to avoid problems
NB. cut up per row, drop the [ ] and convert to numbers
$dat_t =: ((4 2 $ ".)@}:@}.;._2) (true='-')} true ,: '_'
10 4 2
$dat_f =: ((4 2 $ ".)@}:@}.;._2) (false='-')}false,: '_'
10 4 2
NB. this results in arrays with shape 10 4 2
NB. for each 4 x 2 array (rank 2), do c for all true instances
c=:*./@(>:&0)@({.(,(1-+/))@%.|:@}.)@(}:-"1{:)
c"2 dat_t
1 1 1 1 1 1 1 1 1 1
NB. the same for the false ones, demonstrating anonymous usage
NB. still a function though (or verb in J parlance)
*./@(>:&0)@({.(,(1-+/))@%.|:@}.)@(}:-"1{:)"2 dat_f
0 0 0 0 0 0 0 0 0 0
```
[Answer]
## HTML5 + JS, 13b + 146b / 141b / 114 chars
HTML:
```
<canvas id=C>
```
JS (146b):
```
// @params: t1x, t1y, t2x, t2y, t3x, t3y, pointx, pointy
function T(a,b,c,d,e,f,g,h){with(C.getContext("2d"))return beginPath(),moveTo(a,b),lineTo(c,d),lineTo(e,f),fill(),!!getImageData(g,h,1,1).data[3]}
```
or ES6 (141b):
```
T=(a,b,c,d,e,f,g,h)=>{with(C.getContext("2d"))return beginPath(),moveTo(a,b),lineTo(c,d),lineTo(e,f),fill(),!!getImageData(g,h,1,1).data[3]}
```
or ES6 unicode-obfuscated (114 chars):
```
eval(unescape(escape('•ÄΩöÅ°õÅ¢õÅ£õŧõÅ•õŶõÅßõÅ®öêΩü°ª≠±©≠Å®öÅÉõ°ß©ë¥†±Ø´°¥©ë∏≠Ä®ò†≤©Ä¢öꩨ°•≠ŵ¨°ÆòÅ¢©ëß™ëƧŰ≠Å®öÄ©õÅ≠´±∂©ëî´∞®®ê¨®†©õŨ™ëÆ©ëî´∞®®∞¨©Ä©õŨ™ëÆ©ëî´∞®©ê¨©†©õŶ™ë¨´Ä®öê¨òê°©±•≠Åâ´ë°©±•°Å°≠Å°öÅßõÅ®õıõıöêÆ©Å°≠Å°¶∞≥ßëΩ').replace(/uD./g,'')))
```
demo:
<http://jsfiddle.net/xH8mV/>
Unicode obfuscation made with:
<http://xem.github.io/obfuscatweet/>
[Answer]
# Python (65)
People seem to be done submitting, so I'll post my own solution to my question.
```
f=lambda X,L:sum(((L[i-1]-X)/(L[i]-X)).imag>0for i in(0,1,2))%3<1
```
`X` is the complex number representing the test points, and `L` is a list of three points, each a complex number.
First, I'll explain a less golfed version of the code;
```
def f(X,A,B,C):A-=X;B-=X;C-=X;return((A/B).imag>0)==((B/C).imag>0)==((C/A).imag>0)
```
We shift the points `A,B,C,X` so that `X` is at the origin, taking advantage of Python's built-in complex arithmetic. We need to check if the origin is contained in the convex hull of `A,B,C`. This is equivalent to the origin always lying on the same side (left or right) of the line segments AB, BC, and AC.
A segment `AB` has the origin on the left if one travel counterclockwise less than 180 degrees to get from A to B, and on the right otherwise. If we consider the angles `a`, `b`, and `c` corresponding to these points, this means `b-a < 180 degrees` (taken angles in the range 0 to 360 degrees). As complex numbers, `angle(B/A)=angle(B)/angle(A)`. Also, `angle(x) < 180 degrees` exactly for point in he upper half-plane, which we check via `imag(x)>0`.
So whether the origin lies to the left of AB is expressed as `(A/B).imag>0`. Checking whether these are all equal for each cyclic pair in `A,B,C` tells us whether triangle `ABC` contains the origin.
Now, let's return to the fully golfed code
```
f=lambda X,L:sum(((L[i-1]-X)/(L[i]-X)).imag>0for i in(0,1,2))%3<1
```
We generate each cyclic pair in `(A-X,B-X,C-X)=(L[0]-X,L[1]-X,L[2]-X)`, taking advantage of negative Python list indices wrapping around (`L[-1]` = `L[2]`). To check that the Bools are all `True` (`1`) or all `False` (`0`), we add them and check divisibility by 3, as many solutions did.
[Answer]
# Fortran - ~~232~~ ~~218~~ ~~195~~ 174
Bloody awful. The function is horrendous because of the requirement that the data is passed to it and we cannot preprocess it.
```
logical function L(x);real::x(8);p=x(1)-x(3);q=x(2)-x(4);r=x(5)-x(3);s=x(6)-x(4);t=x(7)-x(3);u=x(8)-x(4);L=ALL([p*(s-u)+q*(t-r)+r*u-t*s,p*u-q*t,q*r-p*s]>=r*u-t*s);endfunction
```
The decrease of 14 characters is because I forgot to golf the function name from my test runs. The further decrease is due to implicit typing and forgetting to change the function name. The next 20 characters came off due to reading in the points as a single array. The full program is
```
program inTriagle
real, dimension(2) :: a,b,c,x
do
print*,"Enter coordinates as x,a,b,c"
read*,x,a,b,c
if(all(x==0.0).and.all(a==0.0).and.all(b==0.0).and.all(c==0.0)) exit
print*,"Is point in triangle: ",T(x,a,b,c)
enddo
contains!
logical function L(x)
real::x(8)
p=x(1)-x(3);q=x(2)-x(4);r=x(5)-x(3)
s=x(6)-x(4);t=x(7)-x(3);u=x(8)-x(4)
L=ALL([p*(s-u)+q*(t-r)+r*u-t*s,p*u-q*t,q*r-p*s]>=r*u-t*s)
endfunction
end program inTriagle
```
[Answer]
# MATLAB: 9!
Not a whole lot of me to write here
```
inpolygon
```
Can be called like so:
```
inpolygon(2/3, 2/3, [0 1 1], [0 0 1])
```
Output is assigned to a variable named `ans`
---
If I actually had to write a function, it may be something like so, could probably be optimized:
```
function y=f(a,b,c,d)
inpolygon(a,b,c,d)
```
[Answer]
# C# 218 (149?)
```
using P=System.Drawing.PointF;
bool F(P[]p){for(int i=0;i<4;i++){p[i].X*=1e7f;p[i].Y*=1e7f;}P[]a=new P[3];Array.Copy(p,1,a,0,3);var g=new System.Drawing.Drawing2D.GraphicsPath();g.AddLines(a);return g.IsVisible(p[0]);}
```
Probably not as character-efficient as a mathematical method, but it's a fun use of libraries. Incidentally, also rather slow.
Also taking advantage of "Also don't worry about numerical stability or floating-point precision." - unfortunately, `GraphicsPath` uses `int`s internally, so a value in the range -1 < f < 1 can only have three possible values. Since floats only have 7 digits of precision, I just multiply by 1e7 to turn them into whole numbers. Hm, I guess it's not really *losing* any precision. It's also exploitable in another way: I probably could have taken advantage of ignoring precision and just given the "wrong" answer.
*If* I'm allowed to ignore the character cost of importing libraries, **149** (at the very least, `System.Linq` and `System.Drawing` are pretty standard on most WinForms projects, but `System.Drawing.Drawing2D` might be a bit of a stretch):
```
bool G(PointF[]p){for(int i=0;i<4;i++){p[i].X*=1e7f;p[i].Y*=1e7f;}var g=new GraphicsPath();g.AddLines(p.Skip(1).ToArray());return g.IsVisible(p[0]);}
```
Test program (yea, it's ugly):
```
using System;
using System.Drawing;
using System.Drawing.Drawing2D;
using P=System.Drawing.PointF;
using System.Linq;
class Program
{
static void Main(string[] args)
{
Program prog = new Program();
foreach (string test in
@"[(-0.31961, -0.12646), (0.38478, 0.37419), (-0.30613, -0.59754), (-0.85548, 0.6633)]
[(-0.87427, -0.00831), (0.78829, 0.60409), (-0.90904, -0.13856), (-0.80685, 0.48468)]
[(0.28997, -0.03668), (-0.28362, 0.42831), (0.39332, -0.07474), (-0.48694, -0.10497)]
[(-0.07783, 0.04415), (-0.34355, -0.07161), (0.59105, -0.93145), (0.29402, 0.90334)]
[(0.36107, 0.05389), (0.27103, 0.47754), (-0.00341, -0.79472), (0.82549, -0.29028)]
[(-0.01655, -0.20437), (-0.36194, -0.90281), (-0.26515, -0.4172), (0.36181, 0.51683)]
[(-0.12198, -0.45897), (-0.35128, -0.85405), (0.84566, 0.99364), (0.13767, 0.78618)]
[(-0.03847, -0.81531), (-0.18704, -0.33282), (-0.95717, -0.6337), (0.10976, -0.88374)]
[(0.07904, -0.06245), (0.95181, -0.84223), (-0.75583, -0.34406), (0.16785, 0.87519)]
[(-0.33485, 0.53875), (-0.25173, 0.51317), (-0.62441, -0.90698), (-0.47925, 0.74832)]
[(-0.99103, 0.43842), (0.78128, -0.10985), (-0.84714, -0.20558), (-0.08925, -0.78608)]
[(0.15087, -0.56212), (-0.87374, -0.3787), (0.86403, 0.60374), (0.01392, 0.84362)]
[(0.1114, 0.66496), (-0.92633, 0.27408), (0.92439, 0.43692), (0.8298, -0.29647)]
[(0.87786, -0.8594), (-0.42283, -0.97999), (0.58659, -0.327), (-0.22656, 0.80896)]
[(0.43525, -0.8923), (0.86119, 0.78278), (-0.01348, 0.98093), (-0.56244, -0.75129)]
[(-0.73365, 0.28332), (0.63263, 0.17177), (-0.38398, -0.43497), (-0.31123, 0.73168)]
[(-0.57694, -0.87713), (-0.93622, 0.89397), (0.93117, 0.40775), (0.2323, -0.30718)]
[(0.91059, 0.75966), (0.60118, 0.73186), (0.32178, 0.88296), (-0.90087, -0.26367)]
[(0.3463, -0.89397), (0.99108, 0.13557), (0.50122, -0.8724), (0.43385, 0.00167)]
[(0.88121, 0.36469), (-0.29829, 0.21429), (0.31395, 0.2734), (0.43267, -0.78192)]".Split('\n'))
{
string t = test.Replace("[(", "").Replace(")]", "");
string[] points = t.Split(new string[] { "), (" }, StringSplitOptions.None);
string[] p = points[0].Split(',');
P[] xabc = new P[4];
for (int i = 0; i < 4; i++)
{
p = points[i].Split(',');
xabc[i] = new F(float.Parse(p[0]), float.Parse(p[1]));
}
Console.WriteLine(test + "=>" + prog.F(xabc));
}
Console.ReadKey();
}
bool G(PointF[]p)
{
for(int i=0;i<4;i++){p[i].X*=1e7f;p[i].Y*=1e7f;}
var g=new GraphicsPath();
g.AddLines(p.Skip(1).ToArray());
return g.IsVisible(p[0]);
}
bool F(P[]p)
{
for(int i=0;i<4;i++){p[i].X*=1e7f;p[i].Y*=1e7f;}
var g=new System.Drawing.Drawing2D.GraphicsPath();
g.AddLines(p.Skip(1).ToArray());
return g.IsVisible(p[0]);
}
}
```
[Answer]
### Haskell — ~~233~~ 127
Using cross products as described [here](https://math.stackexchange.com/a/51328):
```
h(a,b)(p,q)(r,s)(t,u)=z a b p q r s==z a b r s t u&&z a b r s t u==z a b t u p q where z j k l m n o =(o-m)*(j-l)+(l-n)*(k-m)>0
```
Previous solution implemented using [barycentric coordinates](http://en.wikipedia.org/wiki/Barycentric_coordinate_system#Determining_whether_a_point_is_inside_a_triangle) and the formulae described in this Stack Exchange [answer](https://math.stackexchange.com/a/51459):
```
g(p,q)(r,s)(t,u)(v,w)=
let (j,k)=(p+(-r),q+(-s))
(l,m)=(t+(-r),u+(-s))
(n,o)=(v+(-r),w+(-s))
d=l*o-n*m
a=(j*(m-o)+k*(n-l)+l*o-n*m)/d
b=(j*o-k*n)/d
c=(k*l-j*m)/d
in (0<=a&&a<1)&&(0<=b&&b<1)&&(0<=c&&c<1)
```
Both functions `g` and `h` take four pairs, the first of which is the point to be tested for inclusion and the rest being the coordinates of the vertices of the triangle.
To test with the sample input:
```
let trueTestCases =
[((-0.31961, -0.12646), (0.38478, 0.37419), (-0.30613, -0.59754), (-0.85548, 0.6633)),
((-0.87427, -0.00831), (0.78829, 0.60409), (-0.90904, -0.13856), (-0.80685, 0.48468)),
((0.28997, -0.03668), (-0.28362, 0.42831), (0.39332, -0.07474), (-0.48694, -0.10497)),
((-0.07783, 0.04415), (-0.34355, -0.07161), (0.59105, -0.93145), (0.29402, 0.90334)),
((0.36107, 0.05389), (0.27103, 0.47754), (-0.00341, -0.79472), (0.82549, -0.29028)),
((-0.01655, -0.20437), (-0.36194, -0.90281), (-0.26515, -0.4172), (0.36181, 0.51683)),
((-0.12198, -0.45897), (-0.35128, -0.85405), (0.84566, 0.99364), (0.13767, 0.78618)),
((-0.03847, -0.81531), (-0.18704, -0.33282), (-0.95717, -0.6337), (0.10976, -0.88374)),
((0.07904, -0.06245), (0.95181, -0.84223), (-0.75583, -0.34406), (0.16785, 0.87519)),
((-0.33485, 0.53875), (-0.25173, 0.51317), (-0.62441, -0.90698), (-0.47925, 0.74832))]
let falseTestCases =
[((-0.99103, 0.43842), (0.78128, -0.10985), (-0.84714, -0.20558), (-0.08925, -0.78608)),
((0.15087, -0.56212), (-0.87374, -0.3787), (0.86403, 0.60374), (0.01392, 0.84362)),
((0.1114, 0.66496), (-0.92633, 0.27408), (0.92439, 0.43692), (0.8298, -0.29647)),
((0.87786, -0.8594), (-0.42283, -0.97999), (0.58659, -0.327), (-0.22656, 0.80896)),
((0.43525, -0.8923), (0.86119, 0.78278), (-0.01348, 0.98093), (-0.56244, -0.75129)),
((-0.73365, 0.28332), (0.63263, 0.17177), (-0.38398, -0.43497), (-0.31123, 0.73168)),
((-0.57694, -0.87713), (-0.93622, 0.89397), (0.93117, 0.40775), (0.2323, -0.30718)),
((0.91059, 0.75966), (0.60118, 0.73186), (0.32178, 0.88296), (-0.90087, -0.26367)),
((0.3463, -0.89397), (0.99108, 0.13557), (0.50122, -0.8724), (0.43385, 0.00167)),
((0.88121, 0.36469), (-0.29829, 0.21429), (0.31395, 0.2734), (0.43267, -0.78192))]
type Point = (Double, Double)
test :: [(Point, Point, Point, Point)] -> [Bool]
test testCases =
map (\((px,py),(ax,ay),(bx,by),(cx,cy)) -> h (px,py) (ax,ay) (bx,by) (cx,cy)) testCases
test trueTestCases --> [True,True,True,True,True,True,True,True,True,True]
test falseTestCases --> [False,False,False,False,False,False,False,False,False,False]
```
Ungolfed solutions:
```
type Point = (Double, Double)
-- using cross products
triangulate' (a, b) (p, q) (r, s) (t, u) =
(side a b p q r s == side a b r s t u) && (side a b r s t u == side a b t u p q)
where side j k l m n o = (o - m) * (j - l) + (-n + l) * (k - m) >= 0
-- using barycentric coordinates
triangulate :: (Point, Point, Point, Point) -> Bool
triangulate ((px, py), (ax, ay), (bx, by), (cx, cy)) =
let (p'x, p'y) = (px + (-ax), py + (-ay))
(b'x, b'y) = (bx + (-ax), by + (-ay))
(c'x, c'y) = (cx + (-ax), cy + (-ay))
d = b'x * c'y - c'x * b'y
a = (p'x * (b'y - c'y) + p'y * (c'x - b'x) + b'x * c'y - c'x * b'y) / d
b = (p'x * c'y - p'y * c'x) / d
c = (p'y * b'x - p'x * b'y) / d
in
(0 <= a && a < 1) && (0 <= b && b < 1) && (0 <= c && c < 1)
```
[Answer]
# JavaScript (ES6) 120
```
C=(p,q,i,j,k,l,m,n,
z=j*(m-k)+i*(l-n)+k*n-l*m,
s=(j*m-i*n+(n-j)*p+(i-m)*q)/z,
t=(i*l-j*k+(j-l)*p+(k-i)*q)/z
)=>s>0&t>0&s+t<1
```
Directly copied from my answer to [This other question](https://codegolf.stackexchange.com/questions/40343/triangular-battleships-a-computational-geometry-problem)
**Test** In FireFox/FireBug console
*Output* all 1s
```
;[
C(-0.31961, -0.12646, 0.38478, 0.37419, -0.30613, -0.59754, -0.85548, 0.6633),
C(-0.87427, -0.00831, 0.78829, 0.60409, -0.90904, -0.13856, -0.80685, 0.48468),
C(0.28997, -0.03668, -0.28362, 0.42831, 0.39332, -0.07474, -0.48694, -0.10497),
C(-0.07783, 0.04415, -0.34355, -0.07161, 0.59105, -0.93145, 0.29402, 0.90334),
C(0.36107, 0.05389, 0.27103, 0.47754, -0.00341, -0.79472, 0.82549, -0.29028),
C(-0.01655, -0.20437, -0.36194, -0.90281, -0.26515, -0.4172, 0.36181, 0.51683),
C(-0.12198, -0.45897, -0.35128, -0.85405, 0.84566, 0.99364, 0.13767, 0.78618),
C(-0.03847, -0.81531, -0.18704, -0.33282, -0.95717, -0.6337, 0.10976, -0.88374),
C(0.07904, -0.06245, 0.95181, -0.84223, -0.75583, -0.34406, 0.16785, 0.87519),
C(-0.33485, 0.53875, -0.25173, 0.51317, -0.62441, -0.90698, -0.47925, 0.74832)
]
```
*Output* all 0s
```
;[
C(-0.99103, 0.43842,0.78128, -0.10985,-0.84714, -0.20558,-0.08925, -0.78608),
C(0.15087, -0.56212,-0.87374, -0.3787,0.86403, 0.60374,0.01392, 0.84362),
C(0.1114, 0.66496,-0.92633, 0.27408,0.92439, 0.43692,0.8298, -0.29647),
C(0.87786, -0.8594,-0.42283, -0.97999,0.58659, -0.327,-0.22656, 0.80896),
C(0.43525, -0.8923,0.86119, 0.78278,-0.01348, 0.98093,-0.56244, -0.75129),
C(-0.73365, 0.28332,0.63263, 0.17177,-0.38398, -0.43497,-0.31123, 0.73168),
C(-0.57694, -0.87713,-0.93622, 0.89397,0.93117, 0.40775,0.2323, -0.30718),
C(0.91059, 0.75966,0.60118, 0.73186,0.32178, 0.88296,-0.90087, -0.26367),
C(0.3463, -0.89397,0.99108, 0.13557,0.50122, -0.8724,0.43385, 0.00167),
C(0.88121, 0.36469,-0.29829, 0.21429,0.31395, 0.2734,0.43267, -0.78192)
]
```
[Answer]
# SmileBASIC, ~~111~~ 100 characters
```
DEF T X,Y,A,B,C,D,E,F
Q=9e5GCLS
GTRI(A-X)*Q,Q*(B-Y),Q*(C-X),Q*(D-Y),Q*(E-X),Q*(F-Y)?!!GSPOIT(0,0)END
```
Draws a triangle and checks the color of the pixel at the point.
The triangle is scaled up 99999x and shifted so that the point to check will be at (0,0) before being drawn, to minimize loss in precision.
[Answer]
# Intel 8087 FPU assembly, ~~222~~ 220 bytes
Uses only the 8087 FPU hardware to calculate. Here is the unassembled (ungolfed in this case too) version as a MACRO (will spare you the 220 hex byte codes):
```
; calculate the area of of a triangle ABC using determinate
; input: coordinates (float), Ax,Ay,Bx,By,Cx,Cy
; output: area in ST
TAREA MACRO A1,A2,B1,B2,C1,C2
FLD A1
FLD B2
FLD C2
FSUB ; ST = By - Cy
FMUL ; ST = Ax * ( By - Cy )
FLD B1
FLD C2
FLD A2
FSUB ; ST = Cy - Ay
FMUL ; ST = Bx * ( Cy - Ay )
FLD C1
FLD A2
FLD B2
FSUB ; Ay - By
FMUL ; Cx * ( Ay - By )
FADD ; Cx * ( Ay - By ) + Bx * ( Cy - Ay )
FADD ; Cx * ( Ay - By ) + Bx * ( Cy - Ay ) + Ax * ( By - Cy )
FLD1 ; make a value of 2
FADD ST,ST ; ST = 2
FDIV ; divide by 2
FABS ; take abs value
ENDM
; determine if point X is in triangle ABC
; input: points X, A, B, C
; output: ZF=1 if X in triangle, ZF=0 if X not in triangle
TXINABC MACRO X1,X2,A1,A2,B1,B2,C1,C2
TAREA A1,A2,B1,B2,C1,C2 ; ST(3) = area of triangle ABC
TAREA X1,X2,B1,B2,C1,C2 ; ST(2) = area of triangle XBC
TAREA A1,A2,X1,X2,C1,C2 ; ST(1) = area of triangle AXC
TAREA A1,A2,B1,B2,X1,X2 ; ST(0) = area of triangle ABX
FADD ; add areas of triangles with point
FADD ; ST = ST + ST(1) + ST(2)
FCOMPP ; compare ST to ST(1) and pop results
FWAIT ; sync CPU/FPU
FSTSW R ; store result flags to R
MOV AX, R ; move result to AX
SAHF ; store result into CPU flags for conditional check
ENDM
```
## Explanation
Uses the determinate to calculate the area of the ABC triangle, and then the triangle formed with the X point and two other points of the ABC triangle. If the area of triangle ABC equals the sum of areas of triangles XBC + AXC + ABX, then the point is within the triangle. The result is returned as ZF.
### What's neat about this
All of the math and floating point operations are done in hardware with 80-bit extended precision. The final floating point comparison is also done in hardware so will be very accurate.
This also uses all eight of the 8087's stack registers at once.
### What's not quite as neat about this
As the points of the triangle must be plugged back into the formulas several times during the calculation, it requires each variable in memory to be loaded into the FPU's stack registers one at a time in the correct order. While this can be fairly easily modeled like a function as a MACRO, it means that the code is expanded each time at assembly, creating redundant code. 41 bytes were saved by moving some of the same repeated code segments into PROCs. However it makes the code less readable, so the above listing is without it (which is why it's labeled as "ungolfed").
## Tests
Here is a test program using IBM DOS showing output:
```
TTEST MACRO T
LOCAL IS_IN_TRI
TXINABC T,T+4*1,T+4*2,T+4*3,T+4*4,T+4*5,T+4*6,T+4*7
MOV DX, OFFSET TEQ ; load true string by default
JZ IS_IN_TRI ; if ZF=1, it is in triangle, skip to display
MOV DX, OFFSET FEQ ; otherwise ZF=0 means not in triangle, so load false string
IS_IN_TRI:
MOV AH, 9 ; DOS write string function
INT 21H
ENDM
START:
FINIT ; reset 8087
TTEST T0 ; true tests
TTEST T1
TTEST T2
TTEST T3
TTEST T4
TTEST T5
TTEST T6
TTEST T7
TTEST T8
TTEST T9
TTEST F0 ; false tests
TTEST F1
TTEST F2
TTEST F3
TTEST F4
TTEST F5
TTEST F6
TTEST F7
TTEST F8
TTEST F9
RET ; return to DOS
T0 DD -0.31961, -0.12646, 0.38478, 0.37419, -0.30613, -0.59754, -0.85548, 0.6633
T1 DD -0.87427, -0.00831, 0.78829, 0.60409, -0.90904, -0.13856, -0.80685, 0.48468
T2 DD 0.28997, -0.03668, -0.28362, 0.42831, 0.39332, -0.07474, -0.48694, -0.10497
T3 DD -0.07783, 0.04415, -0.34355, -0.07161, 0.59105, -0.93145, 0.29402, 0.90334
T4 DD 0.36107, 0.05389, 0.27103, 0.47754, -0.00341, -0.79472, 0.82549, -0.29028
T5 DD -0.01655, -0.20437, -0.36194, -0.90281, -0.26515, -0.4172, 0.36181, 0.51683
T6 DD -0.12198, -0.45897, -0.35128, -0.85405, 0.84566, 0.99364, 0.13767, 0.78618
T7 DD -0.03847, -0.81531, -0.18704, -0.33282, -0.95717, -0.6337, 0.10976, -0.88374
T8 DD 0.07904, -0.06245, 0.95181, -0.84223, -0.75583, -0.34406, 0.16785, 0.87519
T9 DD -0.33485, 0.53875, -0.25173, 0.51317, -0.62441, -0.90698, -0.47925, 0.74832
F0 DD -0.99103, 0.43842, 0.78128, -0.10985, -0.84714, -0.20558, -0.08925, -0.78608
F1 DD 0.15087, -0.56212, -0.87374, -0.3787, 0.86403, 0.60374, 0.01392, 0.84362
F2 DD 0.1114, 0.66496, -0.92633, 0.27408, 0.92439, 0.43692, 0.8298, -0.29647
F3 DD 0.87786, -0.8594, -0.42283, -0.97999, 0.58659, -0.327, -0.22656, 0.80896
F4 DD 0.43525, -0.8923, 0.86119, 0.78278, -0.01348, 0.98093, -0.56244, -0.75129
F5 DD -0.73365, 0.28332, 0.63263, 0.17177, -0.38398, -0.43497, -0.31123, 0.73168
F6 DD -0.57694, -0.87713, -0.93622, 0.89397, 0.93117, 0.40775, 0.2323, -0.30718
F7 DD 0.91059, 0.75966, 0.60118, 0.73186, 0.32178, 0.88296, -0.90087, -0.26367
F8 DD 0.3463, -0.89397, 0.99108, 0.13557, 0.50122, -0.8724, 0.43385, 0.00167
F9 DD 0.88121, 0.36469, -0.29829, 0.21429, 0.31395, 0.2734, 0.43267, -0.78192
TEQ DB 'In Triangle',0DH,0AH,'$'
FEQ DB 'Not In Triangle',0DH,0AH,'$'
```
### Output
```
In Triangle
In Triangle
In Triangle
In Triangle
In Triangle
In Triangle
In Triangle
In Triangle
In Triangle
In Triangle
Not In Triangle
Not In Triangle
Not In Triangle
Not In Triangle
Not In Triangle
Not In Triangle
Not In Triangle
Not In Triangle
Not In Triangle
Not In Triangle
```
[Answer]
## C 414 (was 465)
Golfed
```
#define D double
int F(D ax,D ay,D bx,D by,D cx,D cy,D px,D py){int y=0;double J,K;D m=(ax-bx<0.001)?(by-ay)/(ax-bx):1000;D b=m*ax+ay;J=m*cx-cy+b;K=m*px-py+b;if(J*K>=0)y=1;return y;}D T[8],k;int i,n;void G(){while(i<8){scanf("%lf",&k);T[i++]=k;}n+=F(T[2],T[3],T[4],T[5],T[6],T[7],T[0],T[1]);n+=F(T[4],T[5],T[6],T[7],T[2],T[3],T[0],T[1]);n+=F(T[2],T[3],T[6],T[7],T[4],T[5],T[0],T[1]);printf(n==3?"True":"False");}
```
Original function declaration added for explanation
```
/**
* determine if points C & P are on same side of line AB
* return 1 if true, 0 otherwise
*/
int PointsSameSide(D ax,D ay,D bx,D by,D cx, D cy, D px, D py);
```
Rewritten as a named function: input via stdin one each line or all in one line space-separated.
```
#define D double
int F(D ax,D ay,D bx,D by,D cx, D cy, D px, D py)
{
int y=0;
double J,K;
D m = (ax-bx<0.001)?(by-ay)/(ax-bx):1000;
D b = m*ax+ay;
J=m*cx-cy+b;
K=m*px-py+b;
if(J*K>=0)y=1;
return y;
}
double T[8],k;
int i,n;
void G()
{
while(i<8){scanf("%lf",&k);T[i++]=k;}
n+=F(T[2],T[3],T[4],T[5],T[6],T[7],T[0],T[1]);
n+=F(T[4],T[5],T[6],T[7],T[2],T[3],T[0],T[1]);
n+=F(T[2],T[3],T[6],T[7],T[4],T[5],T[0],T[1]);
printf(n==3?"True":"False");
}
```
[Answer]
**Java, 149 characters**
```
g=Math.atan2(100*(d-y),(a-x));h=Math.atan2(100*(e-y),(b-x));i=Math.atan2(100*(f-y),(c-x));k=Math.round(Math.abs(g-h)+Math.abs(h-i)+Math.abs(i-g))==6;
```
Horrible considering I have to write "Math." every time. This is the actual program:
```
package mathPackage;
public class InTriangle {
public static void main(String[] args) {
boolean k;
double a=-1,b=0,c=1,d=0,e=1,f=0,x=0,y=0.4;
double g,h,i;
g=Math.atan2(100*(d-y),(a-x));
h=Math.atan2(100*(e-y),(b-x));
i=Math.atan2(100*(f-y),(c-x));
k=Math.round(Math.abs(g-h)+Math.abs(h-i)+Math.abs(i-g))==6;
System.out.println(k);
System.out.println(g);
System.out.println(h);
System.out.println(i);
System.out.print(Math.abs(g-h)+Math.abs(h-i)+Math.abs(i-g));
}
}
```
where a is the x of point a,b is the x of point b, c for x of c, d is y of a, e is y of b, f is the y of c, and x and y are the x and y of the point. The boolean k determines whether it is true or not.
[Answer]
# JavaScript 125/198
If points are provided in 8 arguments:
```
function d(x,y,a,b,c,d,e,f){function z(a,b,c,d){return(y-b)*(c-a)-(x-a)*(d-b)>0}return(z(a,b,c,d)+z(c,d,e,f)+z(e,f,a,b))%3<1}
```
If points are provided in a 2-dimensional array:
```
function c(s){return (z(s[1][0],s[1][1],s[2][0],s[2][1])+z(s[2][0],s[2][1],s[3][0],s[3][1])+z(s[3][0],s[3][1],s[1][0],s[1][1]))%3<1;function z(a,b,c,d){return (s[0][1]-b)*(c-a)-(s[0][0]-a)*(d-b)>0}}
```
This code doesn't use any of those fancy vector math. Instead, it only uses a simple algebra trick to determine if the point is inside the triangle or not. The formula:
```
(y-b)(c-a) - (x-a)(d-b)
```
[which tells the point is on which side of a line](https://www.desmos.com/calculator/pmuc3meieh), is derived from rearranging the definition of slope:
```
m = (y2-y1)/(x2-x1)
(y2-y1) = m(x2-x1)
(y-y1) = m(x-x1) ,substituting point we are testing (x,y) to be the 2nd point
(y-y1) = (x-x1)(y2-y1)/(x2-x1) ,substitute back the original definition of m
(y-y1)(x2-x1) = (x-x1)(y2-y1) <-- left side will be greater than the right side, if
the point is on the left; otherwise, it's on the right
0 = (y-b)(c-a)-(x-a)(d-b) ,where (a,b)=(x1,y1), (c,d)=(x2,y2)
```
If we test all 3 sides, all 3 should yield some numbers with the same sign only when the point is inside the triangle since we are testing it around the triangle. If the point is on a side then one of the test should return 0.
jsFiddle test code: <http://jsfiddle.net/DerekL/zEzZU/>
```
var l = [[-0.31961, -0.12646, 0.38478, 0.37419, -0.30613, -0.59754, -0.85548, 0.6633],[-0.87427, -0.00831, 0.78829, 0.60409, -0.90904, -0.13856, -0.80685, 0.48468],[0.28997, -0.03668, -0.28362, 0.42831, 0.39332, -0.07474, -0.48694, -0.10497],[-0.07783, 0.04415, -0.34355, -0.07161, 0.59105, -0.93145, 0.29402, 0.90334],[0.36107, 0.05389, 0.27103, 0.47754, -0.00341, -0.79472, 0.82549, -0.29028],[-0.01655, -0.20437, -0.36194, -0.90281, -0.26515, -0.4172, 0.36181, 0.51683],[-0.12198, -0.45897, -0.35128, -0.85405, 0.84566, 0.99364, 0.13767, 0.78618],[-0.03847, -0.81531, -0.18704, -0.33282, -0.95717, -0.6337, 0.10976, -0.88374],[0.07904, -0.06245, 0.95181, -0.84223, -0.75583, -0.34406, 0.16785, 0.87519],[-0.33485, 0.53875, -0.25173, 0.51317, -0.62441, -0.90698, -0.47925, 0.74832],
[-0.99103, 0.43842, 0.78128, -0.10985, -0.84714, -0.20558, -0.08925, -0.78608],[0.15087, -0.56212, -0.87374, -0.3787, 0.86403, 0.60374, 0.01392, 0.84362],[0.1114, 0.66496, -0.92633, 0.27408, 0.92439, 0.43692, 0.8298, -0.29647],[0.87786, -0.8594, -0.42283, -0.97999, 0.58659, -0.327, -0.22656, 0.80896],[0.43525, -0.8923, 0.86119, 0.78278, -0.01348, 0.98093, -0.56244, -0.75129],[-0.73365, 0.28332, 0.63263, 0.17177, -0.38398, -0.43497, -0.31123, 0.73168],[-0.57694, -0.87713, -0.93622, 0.89397, 0.93117, 0.40775, 0.2323, -0.30718],[0.91059, 0.75966, 0.60118, 0.73186, 0.32178, 0.88296, -0.90087, -0.26367],[0.3463, -0.89397, 0.99108, 0.13557, 0.50122, -0.8724, 0.43385, 0.00167],[0.88121, 0.36469, -0.29829, 0.21429, 0.31395, 0.2734, 0.43267, -0.78192]];
function d(x,y,a,b,c,d,e,f){function z(a,b,c,d){return(y-b)*(c-a)-(x-a)*(d-b)>0}return(z(a,b,c,d)+z(c,d,e,f)+z(e,f,a,b))%3<1}
for(var i = 0; i < l.length; i++){
console.log(d.apply(undefined,l[i])); //10 true, 10 false
}
```
---
**97 characters** (not counting spaces or tabs) count if converted into CoffeeScript:
```
d=(x,y,a,b,c,d,e,f)->
z=(a,b,c,d)->
(y-b)*(c-a)-(x-a)*(d-b)>0
(z(a,b,c,d)+z(c,d,e,f)+z(e,f,a,b))%3<1
```
**115 characters** if converted into ES6:
```
d=(x,y,a,b,c,d,e,f)=>{z=(a,b,c,d)=>{return (y-b)*(c-a)-(x-a)*(d-b)>0};return(z(a,b,c,d)+z(c,d,e,f)+z(e,f,a,b))%3<1}
```
[Answer]
## R, 23
Inspired by [MATLAB](https://codegolf.stackexchange.com/a/32941/26904),
```
SDMTools::pnt.in.poly()
```
called like `SDMTools::pnt.in.poly(point,triangle)` where `point` is a length-2 vector and `triangle` is a 3x2 matrix of vertices. SDMTools is available on CRAN.
[Answer]
# Mathematica, 38 characters
```
RegionMember[Polygon[#[[1]]],#[[2]]] &
```
Example:
```
d = {{{0, 0}, {1, 0}, {.5, .7}}, {.5, .6}};
RegionMember[Polygon[#[[1]]], #[[2]]] & @ d
```
(\* True \*)
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 108 bytes
```
i;f(a,b,c,d,e,f,g,h)float a,b,c,d,e,f,g,h;{i=(e-=a)*(h-=b)>(f-=b)*(g-=a);i=(c-=a)*f>(d-=b)*e==i&i==g*d>h*c;}
```
[Try it online!](https://tio.run/##dVXLbiQ3DLznKwYLJOgxehbiQ3xgMP6SXLxjjz3AxgmCvS322x2KVF8C96kFSV0kq4rU9fR6vX583M@35Wn9tl7X5/Vlva2v69vx9v3vpx@H/@2ef94vy8vp8nR8WN5Ol2/Hx@U2Pg/L69g8x@k1T2@Py3MevFwu9z/ul8vrw/Pj28P1/Ovjr6f7@3L8@dvh8M@/9/cft@XL789/vn9Zb8upfSVwgfUQK0BhWQ@xZayWC2XwPKMmQLnqrp1zZb1zXhMhOh7Pn@ObMmreb80Ixn01Q88fG7fC9@atUIGsS@E3sT6usbHY5wHaVzT3iU8ilis0Esw/cYYkJ8K6pawViU18xmzsultBUzUaII0ZetHB1PuEA8kI3aHVlhNw5o3OLdPwRsR7BZBA04TvZEkLKrQMyLpx3RpxqaTOmqCGnYs89Ia2nz7IzBUbU1EVMWfp49cCRumzOoaKELesagOxfYUBwYt37ja1oA5o0yXckg3jLmkvdxIeCyAVLUNEpP0Chh8LCzpNr5pOv4SuVsp6V6h74cfEheY6vWTh5T0Fmm7ma4IlnXeYtBgjlvO1d6MpP7csBUTLoqYdfLeCUL@uhcI6teigVNzSljXy1NibbIyqY/6pbIQjwOcR3DfLBFlYnG4KBAvWZy0KPK0QxVTJlhFOqULbbTPozSrNLgi4ZmfT7CTSOIsN4UpC2jgZ1iMvr3I05C40ANcYYZcB7BgCViNws3VsMHlVJwE4vD/5QRfWPWCLxp3y97D7oBNxSujq7oHUTfoccTGmBmL0QWprwYzsQUf/T9aCPsraAbx4xxie2XdU49GtOa3FHPO0EuC@XZRIaoDYmFrDz8FI@i0cnlmS0eYQitmVWwCYl5RA9rup6zb1gh7IvKIfsWRy8iFkTDDIBuKYfT02kGYPUMy7XY@MCVgcdI9WHz4AsJmSjQ1CqJdlvAClddt8FSXKrpTEQpPumWIEsxoivY@N3gBx1oXDfExUTddiAu57JNqkXoh4/DwN4PN1QmAcFqFwccmhVMAoOjsGPG396@M/ "C (gcc) – Try It Online")
Takes three cross products and returns `1` if the sign of the `kÃÇ` component doesn't change.
] |
[Question]
[
Your challenge is extremely simple. Given a year as input, print all the months in that year that will contain a [Friday the 13th](https://en.wikipedia.org/wiki/Friday_the_13th) according to the Gregorian calendar. Note that even though the Gregorian Calendar wasn't introduced until 1582, for simplicity's sake we will pretend that it has been in use since 0001 AD.
# Rules
* Full programs or functions are allowed.
* You can take input as function arguments, from STDIN, or as command line arguments.
* You are not allowed to use any date and time builtins.
* You can safely assume that the input will be a valid year. If the input is smaller than 1, not a valid integer, or larger than your languages native number type, you do not have to handle this, and you get undefined behaviour.
* Output can be numbers, in English, or in any other human readable format, so long as you specify the standard.
* Make sure you account for leap-years. And remember, [leap-years do not happen every 4 years!](http://infiniteundo.com/post/25509354022/more-falsehoods-programmers-believe-about-time)
# Tips
Since there are so many different ways to go about this, I don't want to tell you how to do it. However, it might be confusing where to start, so here are a couple different reliable ways of determining the day of the week from a date.
* [Conway's doomsday-algorithm](http://www.timeanddate.com/date/doomsday-weekday.html)
* Pick a start date with a known day of the week, such as [Monday, January 1st, 0001](http://www.timeanddate.com/calendar/?year=1&country=22) and find how far apart the two days are, and take that number mod 7.
* [Gauss's Algorithm](https://en.wikipedia.org/wiki/Determination_of_the_day_of_the_week#Gauss.27s_algorithm)
* [A variation on Gauss's Algorithm](https://en.wikipedia.org/wiki/Determination_of_the_day_of_the_week#Kraitchik.27s_variation)
* [Any of these methods](http://www.wikihow.com/Calculate-the-Day-of-the-Week)
# Sample IO
```
2016 --> May
0001 --> 4, 7
1997 --> Jun
1337 --> 09, 12
123456789 --> January, October
```
As usual, this is code-golf, so standard-loopholes apply, and shortest answer wins.
```
var QUESTION_ID=69510,OVERRIDE_USER=31716;function answersUrl(e){return"http://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"http://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
```
```
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
```
```
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>
```
[Answer]
# Python 2, ~~157~~ ~~144~~ 136 Bytes
My solution uses the Gauss-Algorithm. Input is the year as Integer. Output is the list of months with a friday 13th as numbers (1-12).
Probably some more golfing possible, but its getting late... Gonna edit this one tomorrow und get this down a bit more. Suggestions are always welcome in the meantime!
```
def f(i):y=lambda m:(i-1,i)[m>2];print[m for m in range(1,13)if(13+int(2.6*((m-2)%12,12)[m==2]-.2)+y(m)%4*5+y(m)%100*4+y(m)%400*6)%7==5]
```
**edit:** Got it down to 144 by replacing the for-loop with a list comprehesion und making some other small adjustments.
**edit2:** Golfed it down to 136 with the suggestions from Morgan Thrapp and fixed the bug he discovered. Thanks a lot! :)
[Answer]
# C - ~~164~~ ~~153~~ 112 bytes
I found a nice little solution using a heavily modified version of Schwerdtfeger's method. It encodes the necessary table in an integer using base 7, modified to fit in a signed 32-bit word. It outputs the month as an ASCII-character, with January encoded as `1`, February as `2` and so on, with October encoded as `:`, November encoded as `;` and December encoded as `<`.
```
t=1496603958,m;main(y){for(scanf("%d",&y),y--;(y%100+y%100/4+y/100%4*5+t+5)%7||putchar(m+49),t;t/=7)2-++m||y++;}
```
Here it is slightly ungolfed:
```
t=1496603958,m;
main(y){
for(
scanf("%d",&y),y--;
(y%100+y%100/4+y/100%4*5+t+5)%7||putchar(m+49),t;
t/=7
)
2-++m||y++;
}
```
I am sure there are a few ways to make it even smaller, but I think the algorithm, or a slight variation thereof, is nearly ideal for finding the months where Friday the 13th occurs (with respect to code size). Notes:
1. If a 64-bit word could have been used it would be possible to get rid of an annoying addition (`+5`).
2. The variable `m` isn't actually necessary, since the month we are looking at is deducible from `t`.
I leave my older answer below, seeing as it uses a completely different method not seen in other answers here.
---
This is based on a solution to a related problem (<https://codegolf.stackexchange.com/a/22531/7682>).
```
Y,M,D,d;main(y){for(scanf("%d",&y);Y<=y;++D>28+(M^2?M+(M>7)&1^2:!(Y&3)&&(Y%25||!(Y&15)))&&(D=1,M=M%12+1)<2&&Y++)(d=++d%7)^1||D^13||y^Y||printf("%d,",M);}
```
It basically simulates the Gregorian calendar, advancing one day at a time, printing the month when it is a Friday and the 13th. Here it is in a slightly more readable form:
```
Y,M,D,d;
main(y){
for(
scanf("%d",&y);
Y<=y;
++D>28+(
M^2
?M+(M>7)&1^2
:!(Y&3)&&(Y%25||!(Y&15))
)&&(
D=1,
M=M%12+1
)<2&&Y++
)
(d=++d%7)^1||D^13||y^Y||
printf("%d,",M);
}
```
[Answer]
# Pyth, 73 Bytes
```
L?>b2QtQfq%+++13+/-*2.6?qT2 12%-T2 12 .2 1*5%yT4*4%yT100*6%yT400 7 5r1 13
```
[Try it online!](http://pyth.herokuapp.com/?code=L%3F%3Eb2QtQfq%25%2B%2B%2B13%2B%2F-*2.6%3FqT2%2012%25-T2%2012%20.2%201*5%25yT4*4%25yT100*6%25yT400%207%205r1%2013&input=1997&test_suite=1&test_suite_input=2016%0A1%0A1997%0A1337%0A123456789&debug=0)
Using the Gauss-Algorithm, like in my Python answer. ~55 bytes of the code are for the weekday calculation, so choosing a better algorithm could get this down by a lot I suppose...but hey, at least its working now! :)
[Answer]
# Perl - ~~141~~ ~~107~~ 103 bytes
```
$y=<>-1;map{$y++if++$i==3;print"$i "if($y+int($y/4)-int($y/100)+int($y/400))%7==$_}'634163152042'=~/./g
```
This uses a modified version of the formula for the [Julian day](https://en.wikipedia.org/wiki/Julian_day#Calculation) to calculate the day of the week of March 13th, then uses the number of days of the week each month is offset from January to find the day of the week for the rest of the months, starting with the last 2 months of the previous year beginning in March then the first 10 months of the current year (to avoid calculating leap years twice).
[Answer]
# Excel, 137 bytes
Takes input year in A1. Output is non-separated list of Hexidecimal. (January = 0, December = B)
Uses Gauss's Algorithm for January and August.
```
=CHOOSE(MOD(6+5*MOD(A1-1,4)+4*MOD(A1-1,400),7)+1,"","",1,"","",0,"")&CHOOSE(MOD(5*MOD(A1-1,4)+4*MOD(A1-1,400),7)+1,9,35,"8B",5,"2A",7,4)
```
[Answer]
**C, ~~276~~ 219 bytes**
```
#define R return
#define L(i) for(;i-->0;)
u(y,m){R m-1?30+((2773>>m)&1):28+(y%4==0&&y%100||y%400==0);}s(y,m,g){g+=4;L(m)g+=u(y,m),g%=7;L(y)g+=1+u(y,1),g%=7;R g;}z(y,m,r){m=12;L(m)s(y,m,13)-4||(r|=1<<(m+1));R r;}
```
input from stdin output in stdout try to <http://ideone.com/XtuhGj> [the debug function is z]
```
w(y,m,r){m=12;L(m)s(y,m,u(y,m))||(r|=1<<(m+1));R r;}
/*
// ritorna il numero dei giorni di anno=y mese=m con mese in 0..11
// m==1 significa febbraio y%4?0:y%100?1:!(y%400) non funziona
u(y,m){R m-1?30+((2773>>m)&1):28+(y%4==0&&y%100||y%400==0);}
// argomenti anno:y[0..0xFFFFFFF] mese:m[0..11] giorno:g[1..u(y,m)]
// ritorna il numero del giorno[0..6]
s(y,m,g)
{g+=4; // correzione per il giorno di partenza anno mese giorno = 0,1,1
L(m)g+= u(y,m),g%=7; // m:0..m-1 somma mod 7 i giorni del mese dell'anno y
L(y)g+=1+u(y,1),g%=7; // y:0..y-1 somma mod 7 gli anni da 0..y-1
// g+=1+u(y,1) poiche' (365-28)%7=1 e 1 e' febbraio
R g;
}
// argomenti anno:y[0..0xFFFFFFF], m=0 r=0
// calcola tutti gli ultimi giorni del mese dell'anno y che cadono di lunedi'
// e mette tali mesi come bit, dal bit 1 al bit 12 [il bit 0 sempre 0] in r
w(y,m,r){m=12;L(m)s(y,m,u(y,m))||(r|=1<<(m+1));R r;}
// argomenti anno:y[0..0xFFFFFFF], m=0 r=0
//ritorna in r il numero dei mesi che ha giorno 13 di venerdi[==4]
// e mette tali mesi come bit, dal bit 1 al bit 12 [il bit 0 sempre 0] in r
z(y,m,r){m=12;L(m)s(y,m,13)-4||(r|=1<<(m+1));R r;}
*/
#define P printf
#define W while
#define M main
#define F for
#define U unsigned
#define N int
#define B break
#define I if
#define J(a,b) if(a)goto b
#define G goto
#define P printf
#define D double
#define C unsigned char
#define A getchar()
#define O putchar
#define Y malloc
#define Z free
#define S sizeof
#define T struct
#define E else
#define Q static
#define X continue
M()
{N y,m,g,r,arr[]={1,297,1776,2000,2016,3385}, arr1[]={2016,1,1997,1337,123456789};
C*mese[]={"gen","feb","mar","apr","mag","giu","lug","ago","set","ott","nov","dic"};
C*giorno[]={"Lun","Mar","Mer","Gio","Ven","Sab","Dom"};
P("Inserisci Anno mese giorno>");r=scanf("%d %d %d", &y, &m, &g);
P("Inseriti> %d %d %d r=%d\n", y, m, g, r);
I(r!=3||m>12||m<=0||g>u(y,m-1))R 0;
r=s(y,m-1,g);// 12-> 11 -> 0..10
P("Risultato=%d giorno=%s\n", r, giorno[r]);
r=w(y,0,0);P(" r=%d ", r);P("\n");
F(m=0;m<6;++m)
{P("N anno=%d -->",arr[m]);
r=w(arr[m],0,0); // ritorna in r i mesi tramite i suoi bit...
F(y=1;y<13;++y) I(r&(1<<y))P("%s ",mese[y-1]);
P("\n");
}
F(m=0;m<4;++m)
{P("N anno=%d -->",arr1[m]);
r=z(arr1[m],0,0); // ritorna in r i mesi tramite i suoi bit...
F(y=1;y<13;++y) I(r&(1<<y))P("%s ",mese[y-1]);
P("\n");
}
}
```
] |
[Question]
[
You are given an encrypted string, encrypted using a very simple substitution cipher.
**Problem**
You do not know what the cipher is but you do know the ciphertext is English and that the most frequent letters in English are *etaoinshrdlucmfwypvbgkqjxz* in that order. The only allowed characters are uppercase letters and spaces. You can do basic analysis - starting from single letters, but you can migrate onto more complex multi-letter analysis - for example, U almost always follows Q, and only certain letters can come twice in a row.
**Examples**
```
clear : SUBMARINE TO ATTACK THE DOVER WAREHOUSE AND PORT ON TUESDAY SUNRISE
cipher: ZOQ DUPAEYSRYDSSDXVYSHEYNRBEUYLDUEHROZEYDANYKRUSYRAYSOEZNDMYZOAUPZE
clear : THE QUICK BROWN FOX BEING QUITE FAST JUMPED OVER THE LAZY DOG QUITE NICELY
cipher: TNAEPDHIGEMZQJLEVQBEMAHL EPDHTAEVXWTEODYUASEQKAZETNAERXFCESQ EPDHTAELHIARC
clear : BUFFALO BUFFALO BUFFALO BUFFALO BUFFALO BUFFALO BUFFALO
cipher: HV WRPDHV WRPDHV WRPDHV WRPDHV WRPDHV WRPDHV WRP
```
**Challenges**
See if you can decrypt the text in each of these ciphers:
* `SVNXIFCXYCFSXKVVZXIHXHERDXEIYRAKXZCOFSWHCZXHERDXBNRHCXZR RONQHXORWECFHCUH`
* `SOFPTGFIFBOKJPHLBFPKHZUGLSOJPLIPKBPKHZUGLSOJPMOLEOPWFSFGJLBFIPMOLEOPXULBSIPLBP`
`KBPBPWLIJFBILUBKHPGKISFG`
* `TMBWFYAQFAZYCUOYJOBOHATMCYNIAOQW Q JAXOYCOCYCHAACOCYCAHGOVYLAOEGOTMBWFYAOBFF`
`ACOBHOKBZYKOYCHAUWBHAXOQW XITHJOV WOXWYLYCU`
* `FTRMKRGVRFMHSZVRWHRSFMFLMBNGKMGTHGBRSMKROKLSHSZMHKMMMMMRVVLVMPRKKOZRMFVDSGOFRW`
I have the substitution matrices and cleartext for each, but I will only reveal them if it becomes too difficult or someone doesn't figure it out.
**The solution which can decrypt the most messages successfully is the winner. If two solutions are equally good, they will be decided by vote counts.**
[Answer]
## Python
I've figured out all the secret phrases, but I won't post them here. Run the code if you care.
The code works by picking a space character, enumerating all possible substitutions for each word, then searching for compatible substitutions. It also allows for some out-of-lexicon words to deal with misspellings in the cleartext :)
I used a large lexicon (~500K words) from <http://wordlist.sourceforge.net/>.
```
import sys,re
# get input
message = sys.argv[1]
# read in lexicon of words
# download scowl version 7.1
# mk-list english 95 > wordlist
lexicon = set()
roman_only = re.compile('^[A-Z]*$')
for word in open('wordlist').read().upper().split():
word=word.replace("'",'')
if roman_only.match(word): lexicon.add(word)
histogram={}
for c in message: histogram[c]=0
for c in message: histogram[c]+=1
frequency_order = map(lambda x:x[1], sorted([(f,c) for c,f in histogram.items()])[::-1])
# returns true if the two maps are compatible.
# they are compatible if the mappings agree wherever they are defined,
# and no two different args map to the same value.
def mergeable_maps(map1, map2):
agreements = 0
for c in map1:
if c in map2:
if map1[c] != map2[c]: return False
agreements += 1
return len(set(map1.values() + map2.values())) == len(map1) + len(map2) - agreements
def merge_maps(map1, map2):
m = {}
for (c,d) in map1.items(): m[c]=d
for (c,d) in map2.items(): m[c]=d
return m
def search(map, word_maps, outside_lexicon_allowance, words_outside_lexicon):
cleartext = ''.join(map[x] if x in map else '?' for x in message)
#print 'trying', cleartext
# pick a word to try next
best_word = None
best_score = 1e9
for (word,subs) in word_maps.items():
if word in words_outside_lexicon: continue
compatible_subs=0
for sub in subs:
if mergeable_maps(map, sub): compatible_subs += 1
unassigned_chars = 0
for c in word:
if c not in map: unassigned_chars += 1 #TODO: duplicates?
if compatible_subs == 0: score = 0
elif unassigned_chars == 0: score = 1e9
else: score = 1.0 * compatible_subs / unassigned_chars # TODO: tweak?
if score < best_score:
best_score = score
best_word = word
if not best_word: # no words with unset characters, except possibly the outside lexicon ones
print cleartext,[''.join(map[x] if x in map else '?' for x in word) for word in words_outside_lexicon]
return True
# use all compatible maps for the chosen word
r = False
for sub in word_maps[best_word]:
if not mergeable_maps(map, sub): continue
r |= search(merge_maps(map, sub), word_maps, outside_lexicon_allowance, words_outside_lexicon)
# maybe this word is outside our lexicon
if outside_lexicon_allowance > 0:
r |= search(map, word_maps, outside_lexicon_allowance - 1, words_outside_lexicon + [best_word])
return r
for outside_lexicon_allowance in xrange(3):
# assign the space character first
for space in frequency_order:
words = [w for w in message.split(space) if w != '']
if reduce(lambda x,y:x|y, [len(w)>20 for w in words]): continue # obviously bad spaces
# find all valid substitution maps for each word
word_maps={}
for word in words:
n = len(word)
maps = []
for c in lexicon:
if len(c) != n: continue
m = {}
ok = 1
for i in xrange(n):
if word[i] in m: # repeat letter
if m[word[i]] != c[i]: ok=0; break # repeat letters map to same thing
elif c[i] in m.values(): ok=0; break # different letters map to different things
else: m[word[i]]=c[i]
if ok: maps.append(m);
word_maps[word]=maps
# look for a solution
if search({space:' '}, word_maps, outside_lexicon_allowance, []): sys.exit(0)
print 'I give up.'
```
[Answer]
## PHP (Incomplete)
This is an incomplete PHP solution which works using the letter frequency information in the question plus a dictionary of words matched with regular expressions based on the most reliable letters in the given word.
At present the dictionary is quite small but with the appropriate expansion I anticipate that results would improve. I have considered the possibility of partial matches but with the current dictionary this results in degradation rather than improvement to the results.
**Even with the current, small dictionary I think I can quite safely say what the fourth message encodes.**
```
#!/usr/bin/php
<?php
if($argv[1]) {
$cipher = $argv[1];
// Dictionary
$words = explode("/", "the/to/on/and/in/is/secret/message");
$guess = explode("/", "..e/t./o./a../i./.s/.e..et/.ess..e");
$az = str_split("_etaoinshrdlucmfwypvbgkqjxz");
// Build table
for($i=0; $i<strlen($cipher); $i++) {
$table[$cipher{$i}]++;
}
arsort($table);
// Do default guesses
$result = str_replace("_", " ", str_replace(array_keys($table), $az, $cipher));
// Apply dictionary
$cw = count($words);
for($i=0; $i<$cw*2; $i++) {
$tokens = explode(" ", $result);
foreach($tokens as $t) {
if(preg_match("/^" . $guess[$i%$cw] . "$/", $t)) {
$result = deenc($words[$i%$cw], $t, $result);
echo $t . ' -> ' . $words[$i%$cw] . "\n";
break;
}
}
}
// Show best guess
echo $result . "\n";
} else {
echo "Usage: " . $argv[0] . " [cipher text]\n";
}
// Quick (non-destructive) replace tool
function deenc($word, $enc, $string) {
$string = str_replace(str_split($enc), str_split(strtoupper($word)), $string);
$string = str_replace(str_split($word), str_split($enc), $string);
return strtolower($string);
}
?>
```
] |
[Question]
[
# Your Challenge:
For a golf Course Of Inputted 'n' length to hole where:
```
'n' is a whole number and a multiple of 5 between 150 and 500
and
1 integer in code = 1 metre
```
You must calculate the least amount of swings it can be completed in using a combination of clubs and ranges.
Here is a visual representation of what this calculator will be working out (in colours):
[](https://i.stack.imgur.com/dhOwF.png)
Disregarding nature and swing paths, you are to find the fewest number of swings.
Firstly, you must have a 'Men Or Women' Option as shown in the pseudocode below:
```
INPUT <- "Men Or Women"
```
Each club option has Two Values. These are the ranges of the distance in which the club's shot may fall. This calculator assumes the player is a pro and can choose how far the shot goes in the range.
~It can only be in multiples of 5~
Higher towards the range of one club overrules Lower towards the range of another.
```
Club Men Women
Driver 200-260 150-200
3-wood 180-235 125-180
5-wood 170-210 105-170
2-iron 170-210 105-170
3-iron 160-200 100-160
4-iron 150-185 90-150
5-iron 140-170 80-140
6-iron 130-160 70-130
7-iron 120-150 65-120
8-iron 110-140 60-110
9-iron 95-130 55-95
PW 80-120 50-80
SW 60-100 40-60
putter 10-30 10-20
```
The input must ask for course length and gender separately, and then calculate and then display the output, which must start with displaying gender, and then look like a list (in order of the clubs to be used and the distance hit.
The final Value Must Be A Putter Distance implying it has
EG:
```
(Gender):
(n)m Course
Driver (x)m
4-iron (x)m
3-iron (x)m
putter (x)m
```
Please Be Aware This is just an example as it could include any combination of clubs.
# Finally:
If there is more than one answer, then all must be displayed with a title above exclaiming the answer like so:
```
(Gender):
(n)m Course
Run 1:
Driver (x)m
4-iron (x)m
3-iron (x)m
putter (x)m
Run 2:
Driver (x)m
4-iron (x)m
3-iron (x)m
putter (x)m
```
and so on...
]
|
[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 8 years ago.
[Improve this question](/posts/70363/edit)
/\* I hope such question is suitable for here\*/
As the batch scripts are pretty limited, hybrid files that embed a code from another language into a batch file are used a lot lately.
Though usually there are some requirements for a good hybrid script:
1. The embedded code should be usable as-it-is - without any ugly batch escaping sequences.
2. There should not be redundant output. E.g. a lot of languages use **/\* \*/** for multi-line comments. If the batch script executes a line that starts with **/ \*** it will print an error message an will continue to the next line .Though it will allow you to hybridize C/C++/C#/Java/... with a batch file the error message cannot be surpassed so this will not count as a good hybrid.
3. No temp files.It's easy to output a lot of code into a temp file that will be later executed , the IO operations will slow the script and on of the main advantages of batch scripting (the speed) will be lost. And more over is a challenging constraint. But this will be not possible for compiling languages and for extension sensitive languages.
Some examples will follow:
[JScript](https://groups.google.com/forum/#!topic/alt.msdos.batch.nt/b8q29_uLfQs) (good for example as it comes with every windows installation) technique invented somewhere in the link by Tom Lavedas :
```
@if (true == false) @end /*
@echo off
cscript //nologo //e:javascript "%~dpnx0" %*
echo Output from the batch.
goto :EOF */
WScript.Echo('Output from the jscript.');
```
The output will be:
>
> Output from the jscript.
>
>
> Output from the batch.
>
>
>
The technique uses the JScript (javascript has no such thing) specific **@** directives to make the code valid (or silent) both for both languages.
Another example (again with JScript) invented by [Ryan Biesemeyer](https://gist.github.com/yaauie/959862):
```
0</* :
@echo off
echo Output from the batch.
cscript /nologo /E:jscript %~f0 %*
exit /b %errorlevel%
*/0;
WScript.Echo('Output from the jscript.');
```
This time is used the redirection priority in batch scripts and `0</* :` will be parsed as `0:</*` .
Here are some info that can help you:
* every line that starts with **@** will be silent - even the invalid commands.
* every line that starts with **:** will be taken as label in batch and will be not executed
* every line that starts with something like `<someWord : someWord` will be silent because of redirection priority
* every line that starts with something like `digit<someWord : someWord` will be silent because of redirection priority (this time the output will be redirected to a stream).In this case will be best to use **0**
* you can use `<space><tab> ; , =` at the beginning of every line - these will be ignored as standard delimiters in batch.Can be useful if some language use some of these as comment.
* if you start a line with `%not_existing_variable%` it will be replaced with nothing.Could be useful if in some language comments start with percent.
* If you finish a line with a caret `^` the next line will be appended at the end.With the caret in batch you can escape the new line.
here's a little bit more [inspiration](http://dostips.com/forum/viewtopic.php?f=3&t=6931)
And here's the challenge. Your script should be with `.bat` or `.cmd` extension . It should contain a code from another language - the code should be used by the second language as it is (no escapes symbols) .REPL tools are accepted with the condition of no escape symbols - except in the line where the REPL tool is invoked. There should not be redundant output. There should be not temp files (with the exception of compiling languages , and file extension sensitive languages - then the file should copy itself in the %TEMP% folder).
Each script should accept one command line argument which will be printed 5 (five) times . Both from the batch part of the code and from the second language prefixed by the language name (for the batch case it should be `BATCH:` for example.If the second language is Ruby it should be `RUBY:`)
For sure this will be not possible with every language , but for many it is achievable.
The winner should propose the most solutions with different languages (or if the language is the same a different kind of techniques should be used like in the two examples above).In case of equal number of solutions the first one 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/65885/edit).
Closed 8 years ago.
[Improve this question](/posts/65885/edit)
A [regular polygon](https://en.wikipedia.org/wiki/Regular_polygon) is a polygon that is equiangular (all angles are equal in measure) and equilateral (all sides have the same length).
Your job is to find out if a given polygon is regular or not.
## Specs
* You will be given a list of Cartesian coordinate 2-tuples which describe the polygon's vertices.
* The points will always make a valid polygon.
* You have to return a truthy / falsey for whether or not the polygon is regular.
* Assume vertices are rounded to the nearest int.
* They might or might not be in order.
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so shortest code in **bytes** wins!
## Test Cases
*Most test cases generated by [this site](http://www.mathopenref.com/coordpolycalc.html).*
```
[(1,2), (3, 2), (1, 0), (3, 0)] -> True
[(1, 1), (5, 3), (7, 7), (3, 5)] -> False
[(550,450), (455,519), (491,631), (609,631), (645,519)] -> True
[(106,81), (94,81), (84,88), (80,100), (84,112), (94,119), (106,119), (116,112), (120,100), (116,88)] -> True
```
]
|
[Question]
[
## Explanation
The **edit distance** between two strings is a function of the minimum possible number of insertions, deletions, or substitutions to convert one word into another word.
Insertions and deletions cost 1, and substitutions cost 2.
For example, the distance between `AB` and `A` is 1, because deletions cost 1 and the only edit needed is the deletion of the `B` character.
The distance between `CAR` and `FAR` is 2, because substitutions cost 2. Another way to look at this is one deletion and one insertion.
## Rules
Given two input strings (supplied however is convenient in your language), your program must find the minimum edit distance between the two strings.
You may assume that the strings only contain the characters `A-Z` and have fewer than 100 characters and more than 0 characters.
This is **code golf**, so the shortest solution wins.
## Sample Test Cases
```
ISLANDER, SLANDER
> 1
MART, KARMA
> 5
KITTEN, SITTING
> 5
INTENTION, EXECUTION
> 8
```
[Answer]
## brainfuck, 2680
```
+>>>>>>>>>>>>>>>>>>>>>>++++++>,<[->-----<]>--[+++++++++++++++++++++
+++++++++++>>[->>+<<]>>+<<,--------------------------------]>>[-<<<
+>>>]<<<<[>[-<<+>>]<<<]>[-<<<<<+>>>>>]>[>>],----------[++++++++++>>
[->>+<<]>>+<<,----------]>>[-<<<+>>>]<<<<[>[-<<+>>]<<<]>[-<<+>>]<<[
-<+>>+<]<<<[->+<]>[-<+>>>>+<<<]>>>[-<+>]<[->+>+<<]<[-<+>]<[->+>+<<]
<[-<+>>+<]<[->+<]>>>>>>[-[->>+<<]<<[->>+<<]<<[->>+<<]>>>>>>]<<[->>+
>+<<<]>>>[-<<<+>>>]<[->>+[->+>+<<]<<[->>+<<]>>]>>[-]<[<<]<<<+[->>>+
<<<]>>>[-<+<<+>>>]<<<<<[->>[->>>>[->>+<<]<<[->>+<<]<<[->>+<<]<<[->>
+<<]>>>>]>>[->>>>+<<<<]>>>>[-<<<<+<<+>>>>>>]<<+[->>+<<]>>[-<<+<+>>>
]<<<<<<<<]>>[-]>>[-]>>[-]-[+<<-]+>>>>>>>>>>>>>>>>>[-<+>]<[->+<<<<+>
>>]<<<[->>>>>>[-<+>]<[->+<<<<+>>>]<<<<<<<[-]<<+>>>>>>[-<<<<+>>>>>>>
>>>[-<+>]<[->+>+<<]<<<<<<<<<[->+<]>[->>>>>>>>+<<<<<<<<<+>]<<<[->+<]
>[->>>>>>>>+<<<<<<<<<+>]>>>>>>>>>[-<<<<<+>>>>>]<<<<<[->>+>>>+<<<<<]
>>>>>>>>[-[->>+<<]<<[->>+<<]<<[->>+<<]<<[->>+<<]>>>>>>>>]<<<<<<+>>-
[-<<[-<<<<+>>>>]<<<<[->>+>>+<<<<]>>[->>>>>>[->>+<<]<<[->>+<<]<<[->>
+<<]<<[->>+<<]>>]>>>>]>>[->>+<<]>>[-<<+>>>>+<<]->>-[-[->>+<<]>>]>[-
>+<]>[-<+>>>+<<]<<<[->+<]>[-<+>>>+<<]+[->>[-<<+>>]>>[-<<+>>]<<<<<<+
]<<<<<<[->>>>>>+<<<<<<]>>>>>>>>[-<<<<<<<<+>>>>>>>>]<<<<[->>>>+<<<<]
-<<[-]>>>>>>>>[-<<<<<<<<+>>>>>>>>]<<<<[->>[->>+<<]<<[->>+<<]>>]>>-[
-[->>+<<]>>]<[->+<]>[-<+>>>+<<]+[->>[-<<+>>]<<<<+]>>[-<<+>>]<<<<<<<
<-[+>>[-<<+>>]>>[-<<+>>]>>[-<<+>>]<<<<<<<<-]+>>>[-]<[->+<]>>>[-]<[-
>+<]>>>[-]<[->+<]>>>[->+<]>[-<+>>>>>>>>>>>>>+<<<<<<<<<<<<]>>>>>>>>>
>>>-[-[->>+<<]>>]>[->+<]>[-<+<+>>]<<<<-[+>>[-<<+>>]<<<<-]+>>[-<+>]>
>>>>>>>>[->+<]>[-<+>>>>>>>>>>>+<<<<<<<<<<]>>>>>[->+<]>[-<+>>>>>+<<<
<]>>>>-[-[->>+<<]>>]>[->+<]>[-<+<+>>]<<<<-[+>>[-<<+>>]<<<<-]+>[->-<
]>[-<[-]+>]<[->>>+<<<]>>>[-<<+<+>>>]<<-[+>[->+<]<]<[->>+<-[[-]>[->+
<]>[-<+>>>+<<]+>>[-<<[-]>>]<[->+<]>[-<+>>>+<<]+>>[-<<[-]>>]<[->+<]>
[-<+>>>+<<]+>>[-<<[-]>>]<<[-<<[-]+>>]<<[-<<[-]+>>]<<[-<<[-]+>>]<<<+
>->->>->>-<<<<<]<[->+<]]>[-<+>]>>[-<<<+>>>]<<<[->>>>>>>>>>>>>+<<<<<
<<<<<<<<]>>>>>>>>[->+<]>[-<+>>>>>>>>>+<<<<<<<<]>[->+<]>[-<+>>>>>>>>
>+<<<<<<<<]>>>>>>>>>[->>>+<<<]>>>[-<<+<+>>>]<<<<<[->>>>>+<<<<<]>>>>
>[-<<<<<+<<<+>>>>>>>>]<<<<<<<<+>>>>>>[-[->>+<<]<<[->>+<<]<<[->>+<<]
<<[->>+<<]<<[->>+<<]>>>>>>>>>>]<<<<[-<<[-<<<<<<+>>>>>>]<<<<<<[->>+>
>>>+<<<<<<]>>[->>>>>>>>[->>+<<]<<[->>+<<]<<[->>+<<]<<[->>+<<]<<[->>
+<<]>>]>>>>>>]<<[-]<<[->>>>+<<<<]>>>>>>[-[->>+<<]<<[->>+<<]>>>>]<<[
->>>>>+<<<<<]-[+<<-]+>>>>>>>>>>>>>>>]<<]>>>>>>>>[->+<]<<[->+<]<<[->
+<]>>>>>[-[->>+<<]<<[->>+<<]<<[->>+<<]>>>>>>]<<<<[->>[->>>>+<<<<]>>
>>[-<<+<<+>>>>]<<+[-[->>+<<]<<[->>+<<]<<[->>+<<]>>>>>>]<<<<]>>[-[->
>+<<]>>]>>>>++++++++++<[->-[>+>>]>[+[-<+>]>+>>]<<<<<]>>>[->-[>+>>]>
[+[-<+>]>+>>]<<<<<]>[-]<++++++[->++++++++[->+>+<<<<+>>]<]>>>.<.<<<.
```
Using dynamic programming, of course.
Input strings should be separated by a space, and followed by a new line. For example:
```
INTENTION EXECUTION
008
```
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog) (v2), 14 bytes
```
⟨⊇⊆⟩jg;?clᵐ-ˡṅ
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/r//9H8FY@62h91tT2avzIr3do@Oefh1gm6pxc@3Nn6/3@0UmZeSWpeSWZ@npKOglJqRWpyKZgT@z8KAA "Brachylog – Try It Online")
This question has a surprising lack of golfing language solutions (there's an APL solution, which is a quasi-golfing language, but it doesn't beat the builtin-based solutions). So here's an attempt to get the ball rolling on that.
I'm not really happy with the golfiness of this; there's a lot of plumbing, as is so often the case when a Brachylog answer takes multiple inputs. In order to comprehensively beat the builtin-based solutions, ideally someone would come up with an answer that's shorter than the word "Levenshtein". Anyone feel like giving that a go?
## Explanation
```
⟨⊇⊆⟩jg;?clᵐ-ˡṅ
⟨ ⟩ Find a value that is related to the first and second inputs:
⊇ {the first input} is a non-continguous superstring of it
⊆ it is a non-contiguous substring of {the second input}
j Concatenate that value to itself
g Form a singleton list containing that value
;?c Append the inputs to that list
lᵐ Take the length of each of the three elements
-ˡ Left fold by subtraction
ṅ Multiply the result by -1
```
The real work is done by the `⟨⊇⊆⟩` at the start, which finds the longest common subsequence of the two inputs (as specified, it just asks for any subsequence, but Brachlog's default tiebreaks will always pick the longest). Let's call the length of this *q*, and the lengths of the inputs *a* and *b*. The edit distance is then equal to *a*-*q*+*b*-*q*; to edit one into the other, we need to delete from one until we reach the common subsequence, then insert until we reach the other (when editing with insertions and deletions, the order doesn't matter).
After our `⟨⊇⊆⟩`, the current implicit variable is a string of length *q*. Doubling this with `j` gives us a string of length 2*q*. After bringing the inputs back into our working value, we have three strings, of lengths [2*q*, *a*, *b*], and can replace these with their lengths. Reducing by subtraction then gives 2*q*-*a*-*b* = -(*a*-*q*+*b*-*q*), so we simply need to negate the answer to get the edit distance.
[Answer]
# Python, 138 148 152 characters
Ok, I knew the principle but had never implemented edit distance before, so here goes:
```
x,y=raw_input().split()
d=range(99)
for a in x:
c=d;d=[d[0]+1]
for b,p,q in zip(y,c[1:],c):d+=[min(d[-1]+1,p+1,q+2*(a!=b))]
print d[-1]
```
[Answer]
## R 51
This reads in two lines from the user (which are the input) and then just uses the `adist` function to calculate the distance. Since substitutions cost 2 for this problem we need to add a named vector for the costs parameter for adist. Since there is also a counts parameter for adist we can only shorten costs to cos so we still have a unique match for the parameter names.
```
x=readLines(n=2);adist(x[1],x[2],cos=c(i=1,d=1,s=2))
```
Example use
```
> x=readLines(n=2);adist(x[1],x[2],cos=c(i=1,d=1,s=2))
MART
KARMA
[,1]
[1,] 5
```
[Answer]
## PHP, 40
Follows the rules as stated, but not the spirit of the rules:
```
<?=levenshtein($argv[1],$argv[2],1,2,1);
```
Takes it's two parameters as arguments. Example calling: `php edit_dist.php word1 word2`.
Normally `levenshtein()` considers a substitution as one operation, but it has an overloaded form where the insert/sub/delete weights can be specified. In this case, its 1/2/1.
[Answer]
# APL (90 characters)
```
⊃⌽({h←1+c←⊃⍵⋄d←h,1↓⍵⋄h,(⊂⍵){y←⍵+1⋄d[y]←⍺{h⌷b=⍵⌷a:⍵⌷⍺⋄1+d[⍵]⌊y⌷⍺}⍵}¨⍳x}⍣(⊃⍴b←,⍞))0,⍳x←⍴a←,⍞
```
I'm using Dyalog APL as my interpreter, with `⎕IO` set to 1 and `⎕ML` set to 0. The direct function (`{ ... }`) computes, given a row as input, the next row in the distance matrix. (It is started with the initial row: `0,⍳x`.) The power operator (`⍣`) is used to nest the function once for each character in the second string (`⊃⍴b`). After all of that, the final row is reversed (`⌽`), and its first element is taken (`⊃`).
Example:
```
⊃⌽({h←1+c←⊃⍵⋄d←h,1↓⍵⋄h,(⊂⍵){y←⍵+1⋄d[y]←⍺{h⌷b=⍵⌷a:⍵⌷⍺⋄1+d[⍵]⌊y⌷⍺}⍵}¨⍳x}⍣(⊃⍴b←,⍞))0,⍳x←⍴a←,⍞
LOCKSMITH
BLACKSMITH
3
⊃⌽({h←1+c←⊃⍵⋄d←h,1↓⍵⋄h,(⊂⍵){y←⍵+1⋄d[y]←⍺{h⌷b=⍵⌷a:⍵⌷⍺⋄1+d[⍵]⌊y⌷⍺}⍵}¨⍳x}⍣(⊃⍴b←,⍞))0,⍳x←⍴a←,⍞
GATTTGTGACGCACCCTCAGAACTGCAGTAATGGTCCAGCTGCTTCACAGGCAACTGGTAACCACCTCATTTGGGGATGTTTCTGCCTTGCTAGCAGTGCCAGAGAGAACTTCATCATTGTCACCTCATCAAAGACTACTTTTTCAGACATCTCCTGTAG
AAGTACTGAACTCCTAATATCACCAATTCTTCTAAGTTCCTGGACATTGATCCGGAGGAGGATTCGCAGTTCAACATCAAGGTAAGGAAGGATACAGCATTGTTATCGTTGTTGAGATATTAGTAAGAAATACGCCTTTCCCCATGTTGTAAACGGGCTA
118
```
[Answer]
# [Husk](https://github.com/barbuz/Husk), ~~10~~ 9 bytes
```
Lṁ-→FnmṖ¹
```
[Try it online!](https://tio.run/##yygtzv6fG6xRnqqpUfyoqbFc89C2/z4PdzbqPmqb5JaX@3DntEM7////n1mck5iXklqkAKW5chOLShSyE4tyE7myM0tKUvMUioFUZl46V2YekFeSmZ@nkFqRmlwKYgEA "Husk – Try It Online")
Inspired by [ais523's Brachylog solution](https://codegolf.stackexchange.com/a/214259/62393), finds the longest common (not necessarily contiguous) subsequence and subtracts it from each string.
~~I don't like having to repeat `Ṗ` twice and having to explicitly refer to the two arguments `¹` and `³`, but I couldn't find any shorter alternative.~~ *Now* I'm happy :)
### Explanation
```
Lṁ-→FnmṖ¹ Input: a list containing the two strings
Ṗ Get all possible subsequences
m ¹ for each string
Fn Keep only the common ones
→ Get the last one (which will be the longest)
- and subtract it
ṁ from each of the inputs, then concatenate the remaining characters
L Find the length of this
```
Subtracting the longest common substring for each input results in the lists of characters that need to be deleted/inserted. We concatenate these two lists and get the length to calculate the edit distance.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 10 bytes
```
ŒP€f/ṪLạẈS
```
[Try it online!](https://tio.run/##y0rNyan8///opIBHTWvS9B/uXOXzcNfCh7s6gv///x@tlJlXkppXkpmfp6SjlFqRmlwKZscCAA "Jelly – Try It Online")
A port to Jelly of [my Brachylog answer](https://codegolf.stackexchange.com/a/214259), saving a few bytes through more convenient plumbing and some convenient builtins (and beating the builtin-based practical language answers by being shorter than the word "Levenshtein"). This is a function submission (although it also works as a full program), taking a list of the two strings.
The algorithm is the same: find the longest common subsequence of the two strings, then add together the differences in lengths between the common subsequence and each of the two original strings.
An odd side effect of this algorithm is that it seems to give an internally consistent definition of the edit difference between three or more strings, as well. I'm not sure if that would be useful for anything, but it's nice to know it exists.
## Explanation
```
ŒP€f/ṪLạẈS
€ On each of the original strings
ŒP produce all possible subsequences of the string;
f take the list of common elements
/ between the first and second sets of subsequences;
L take the length of
Ṫ the last of these common elements;
ạ take the absolute differences between that and
Ẉ the length of each {of the original strings}
S and sum them.
```
Shoutouts to `Ẉ` here for having an implied "each" in it, thus ensuring that Jelly implicitly finds the correct thing to take the length of (if you write `L`, "length", rather than `Ẉ`, "length of each", you get the *number* of strings you started with which is not helpful).
Jelly sorts the subsequences in order from shortest to longest, and `f` returns its output in the same order as in its left argument, so the `Ṫ` is guaranteed to find the longest subsequence. We can save any need to subtract from 0 (like the Brachylog submission does), because we have access to an absolute-difference builtin.
[Answer]
# Smalltalk (Smalltalk/X), 34
I am lucky - the standard "String" class already contains levenshtein:
input a, b:
```
a levenshteinTo:b s:2 k:2 c:1 i:1 d:1
```
(the additional parameters allow for different weights on substitution, deletion, etc.)
Test run:
```
#( 'ISLANDER' 'SLANDER'
'MART' 'KARMA'
'KITTEN' 'SITTING'
'INTENTION' 'EXECUTION'
) pairWiseDo:[:a :b|
a print. ' ' print. b print. ' ' print.
(a levenshteinTo:b
s:2 k:2 c:1 i:1 d:1) printCR.
].
```
->
```
ISLANDER SLANDER 1
MART KARMA 5
KITTEN SITTING 5
INTENTION EXECUTION 8
```
[Answer]
# [Husk](https://github.com/barbuz/Husk), ~~23~~ ~~22~~ 21 bytes
```
`-L+¹³*2▲mλΣz=←¹→)¤*Q
```
[Try it online!](https://tio.run/##yygtzv7/P0HXR/vQzkObtYweTduUe273ucVVto/aJhza@ahtkuahJVqB////T0xKTklN/58GpNLT0wA "Husk – Try It Online")
```
`-+L¹L³*2▲mλΣz=←¹→)¤*Q
`- # reversed minus: a-b
+L¹L³ # a = length of arg1 + length of arg2
*2 # b = 2x
▲ # maximum value of
m # map function to all elements of list
λ # function:
Σ # sum of
z= # elements that are equal between
←¹ # sublist 1 and
→) # sublist 2
* # list: cartesian product of
¤ Q # all sublists of arg1 and arg2
```
[Answer]
**Ruby 1.9, 124**
```
l=->a,b{a[0]?b[0]?[(a[0]==b[0]?-1:1)+l[a[1..-1],b[1..-1]],l[a[1..-1],b],l[a,b[1..-1]]].min+1: a.size: b.size}
puts l[*ARGV]
```
Golfed version of the slow, recursive Ruby method [here](http://en.wikibooks.org/wiki/Algorithm_Implementation/Strings/Levenshtein_distance#Ruby), modified to double the weight for substitutions. The fact that it takes 7 characters to remove the first character of a string really hurts, and it'd be cool to replace `(a[0]==b[0]?-1:1)` with something like `-1**a[0]<=>b[0]` but the order of operations is not my friend.
] |
[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/64237/edit).
Closed 8 years ago.
[Improve this question](/posts/64237/edit)
There are important differences between Python 2 and 3, so it's often useful to know which version of the interpreter is running your code. The straightforward method is something like this:
```
def get_python_version():
import sys
return sys.version_info.major
```
But you can exploit other differences to come up with other solutions to this. My favorite so far is this:
```
def get_python_version():
version = 3;[2 for version in range(3)]
return version
```
What's the most creative/diabolical/entertaining snippet you can come up with that returns the Python version?
]
|
[Question]
[
[Hamming numbers](http://en.wikipedia.org/wiki/Hamming_numbers) are numbers which evenly divide a power of 60. Equivalently, their prime factors are all \$ \le 5 \$.
Given a positive integer, print that many Hamming numbers, in order.
Rules:
* Input will be a positive integer \$n \le 1,000,000 \$
* Output should be the first \$n\$ terms of <https://oeis.org/A051037>
* Execution time must be \$<1\$ minute
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"); shortest code wins
[Answer]
## Haskell, ~~101~~ ~~97~~ 92+|n| characters
```
h=1:m 2h&m 3h&m 5h
m=map.(*)
c@(a:b)&o@(m:n)|a<m=a:b&o|a>m=m:c&n|0<1=a:b&n
main=print$take 1000000h
```
Computes the full million in 3.7s on the machine I tested on (variably more if you actually want the output stored)
Ungolfed:
```
-- print out the first million Hamming numbers
main = print $ take 1000000 h
-- h is the entire Hamming sequence.
-- It starts with 1; for each number in the
-- sequence, 2n, 3n and 5n are also in.
h = 1 : (m 2 h) & (m 3 h) & (m 5 h)
-- helper: m scales a list by a constant factor
m f xs = map (f*) xs
-- helper: (&) merges two ordered sequences
a@(ha:ta) & b@(hb:tb)
| ha < hb = ha : ta & b
| ha > hb = hb : a & tb
| otherwise = ha : ta & tb
```
All Haskell is notoriously good at: defining a list as a lazy function of itself, in a way that actually works.
[Answer]
**Python 181 Characters**
```
h=[]
h.append(1)
n=input()
i=j=k=0
while n:
print h[-1]
while h[i]*2<=h[-1]:
i+=1
while h[j]*3<=h[-1]:
j+=1
while h[k]*5<=h[-1]:
k+=1
h.append(min(h[i]*2,h[j]*3,h[k]*5))
n-=1
```
[Answer]
# [APL (Dyalog Classic)](https://www.dyalog.com/), ~~34~~ 23 bytes
```
{⍺⍴{⍵[⍋⍵]}∪,⍵∘.×⍳5}⍣≡∘1
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNzkksLs5M/v8/7VHbhOpHvbse9W4BUlujH/V2A6nY2kcdq3SAjEcdM/QOT3/Uu9m09lHv4kedC4EChkBdCkZcaQqGBgZcj3o69BXSFEwNQAAA "APL (Dyalog Classic) – Try It Online")
TIO throws a WS FULL error for \$n = 1000000\$, but Dyalog on my laptop runs in about 45 seconds, not counting the scrolling to display numbers.
```
{⍺⍴{⍵[⍋⍵]}∪,⍵∘.×⍳5}⍣≡∘1 Monadic function:
{⍺⍴{⍵[⍋⍵]}∪,⍵∘.×⍳5} Define the following helper function g(⍺,⍵):
⍵∘.×⍳5 Make a multiplication table between ⍵ and (1 2 3 4 5).
(Including 4 is unnecessary but saves bytes.)
, Flatten the table into an array.
∪ Keep unique elements.
{⍵[⍋⍵]} Grade up the array and access it at those indices.
(This is the APL idiom to sort an array.)
⍺⍴ Keep the first ⍺ elements; pad by repeating the array.
{⍺⍴{⍵[⍋⍵]}∪,⍵∘.×⍳5}⍣≡ Repeatedly apply g with some fixed left argument
until a fixed point is reached.
At this point we have a dyadic function that takes
n on the left and the starting value on the right,
and returns multiples of the n Hamming numbers.
∘1 Fix 1 as the right argument.
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `j`, 8 bytes
```
λdǏG7<;ȯ
```
[Try it Online!](https://lyxal.pythonanywhere.com?flags=j&code=%CE%BBd%C7%8FG7%3C%3B%C8%AF&inputs=200&header=&footer=)
```
λ ;ȯ # First n numbers where
dǏG # Maximum of prime factors
7< # Less than 7
```
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal), ~~29~~ 26 bytes, times out when n>=200,000 on online interpreter.
My first ever Vyxal post.
29->26, adviced by @lyxal.
```
6ɽ{:L?<|:2*$:3*$:5*∪∪∪}s?Ẏ
```
## How it works
```
# let first hamming numbers are 1 to 6
6ɽ
# while items of they are less than n; do
{:L?<|
# for each item, multiply with those numbers
# and then unify them; done
:2*$:3*$:5*∪∪∪}
# sort
s
# take first n items
?Ẏ
```
[Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=6%C9%BD%7B%3AL%3F%3C%7C%3A2*%24%3A3*%24%3A5*%E2%88%AA%E2%88%AA%E2%88%AA%7Ds%3F%E1%BA%8E&inputs=200&header=&footer=)
[Answer]
## Ruby - 154 231 characters
```
def k i,n;(l=Math).log(i,2)*l.log(i,3)*l.log(i,5)/6>n end
def l i,n;k(i,n)?[i]:[i]+l(5*i,n)end
def j i,n;k(i,n)?[i]:[i]+j(3*i,n)+l(5*i,n)end
def h i,n;k(i,n)?[i]:[i]+h(2*i,n)+j(3*i,n)+l(5*i,n)end
puts h(1,n=gets.to_i).sort.first n
```
And now it's fast enough, there is definitely a lot of golfing that can still happen though.
```
→ time echo 1000000 | ruby golf-hamming.rb | wc
1000000 1000000 64103205
echo 1000000 0.00s user 0.00s system 0% cpu 0.003 total
ruby golf-hamming.rb 40.39s user 0.81s system 99% cpu 41.229 total
wc 1.58s user 0.05s system 3% cpu 41.228 total
```
[Answer]
# MMIX, 92 bytes (23 instrs)
I'm cheating a bit; instead of printing (which would take a lot of work, this being machine language), I instead pass the numbers to a function passed in!
```
00000000: fe020004 34000100 e3030000 c1040300 “£¡¥4¡¢¡ẉ¤¡¡Ḋ¥¤¡
00000010: e7030001 da040403 3c040304 1d050403 ḃ¤¡¢ḷ¥¥¤<¥¤¥ø¦¥¤
00000020: feff0006 6204ff05 43fffffd 1d050405 “”¡©b¥”¦C””’ø¦¥¦
00000030: feff0006 6204ff05 43fffffd 31ff0401 “”¡©b¥”¦C””’1”¥¢
00000040: 5bfffff3 e7000001 c1050300 bf040100 [””ṙḃ¡¡¢Ḋ¦¤¡Ḃ¥¢¡
00000050: 5b00ffef f6040002 f8000000 [¡”ṁẇ¥¡£ẏ¡¡¡
```
```
smooth5 GET $2,rJ
NEG $0,1,$0 // n = 1 - n
SETL $3,0 // i = 0
0H SET $4,$3
INCL $3,1 // loop: j = i++
SADD $4,$4,$3 // j = popcnt(j & ~i)
SR $4,$3,$4 // j = i >> j (cheap way of getting out factors of 2)
1H DIV $5,$4,3 // lp3: k = j / 3
GET $255,rR // tmp = j % 3
CSZ $4,$255,$5 // if(!tmp) j = k
BZ $255,1B // if(!tmp) goto lp3
1H DIV $5,$4,5 // lp5: k = j / 5
GET $255,rR // tmp = j % 5
CSZ $4,$255,$5 // if(!tmp) j = k
BZ $255,1B // if(!tmp) goto lp3
CMP $255,$4,1 // tmp = j <=> 1
PBNZ $255,0B // iflikely(tmp) goto loop
INCL $0,1 // n++
SET $5,$3
PUSHGO $4,$1,0 // f(i)
PBNZ $0,0B // iflikely(n) goto loop
PUT rJ,$2
POP 0,0 // return
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 9 bytes
```
RḤÆfṀ€<7T
```
[Try it online!](https://tio.run/##y0rNyan8/z/o4Y4lh9vSHu5seNS0xsY85P///4YGAA "Jelly – Try It Online")
Returns all hamming numbers under n.
**How?**
```
RḤÆfṀ€<7T Main Link. Takes n on the left
T Filter by
R Inclusive range
Ḥ Double each
Æf Prime factors
€ For each
Ṁ Maximum
<7 Less than 7
```
My first serious jelly answer
[Answer]
# [Python 3.8 (pre-release)](https://docs.python.org/3.8/), 97 bytes
Inefficient but golfy. Lot's of keywords and whitespace, so potential for more golfing.
```
def f(n):
h=[1]
while(n:=n-1):h+=[min(j*k for j in(2,3,5)for k in h if j*k not in h)]
return h
```
[Try it online!](https://tio.run/##JZDNboMwEITvPMWKE25dCf8AJhKHXipVrdQHQNwKgiR1IkJU9enpjHOwPbM79n7y9W@bL9GF67rv3@MkUxHVIZO5682Qye@8nMciHrr4YtRhfu76nyUWx6eTTJdVjgJjtdOVoj3ByizLJAzEy5a8wjPruN1X6H0bb5t00hstVovT4rVUWmotQUurxZRY6BgUDaoGZYuaRc6iZhvcgne8jb6H9qh75CroCrkaZ42zQaZBL8AHDGxxtnyz5JAycFIax1mW1lF5z/Fs1GkjDZ8wrSULYUhmE45PbI5wVBUbDVUIBE2kafPkpSKRC57oZC@rIcvW8XY/81@m4jzGgp@kVJZd1yVuRZ@/vb5/5jr/@siH/hHtOmYG/XBq/wc "Python 3.8 (pre-release) – Try It Online")
# [Python 3.8 (pre-release)](https://docs.python.org/3.8/), 165 bytes
Slightly golfed version of the [original Python entry](/a/466/86751).
Reposted, because of its age.
```
def f(n):
h=[1];i=j=k=0
while(n:=n-1):
m=h[-1]
while(h[i]*2<=m):i+=1
while(h[j]*3<=m):j+=1
while(h[k]*5<=m):k+=1
h+=[min(h[i]*2,h[j]*3,h[k]*5)]
return h
```
[Try it online!](https://tio.run/##VVBLboMwFNxziidWkDgS/gAmrRfdVKpaqQdA3pXI5ONGhKjq6ekb00W7sD1vZuwZ@fo9h8@o7XValo/hQIcilvuMguulfxjd0Z1cldFXGM9DEfcu7iRkurjQ76RntEqhH/1GPbpLuR@3Tv7hj36jE3/8z5/8pk78aeXD1vWXMf6@JNaLYvWVHDQN832KFJZ5uM3kqJeClCAtyAiqBTWCrKBOkKx4sSKZlMxKphVzin2KOdXyLZ41brNuGBvmDftqxjX7Gj4bPlv2tKxZni0Hdnx2eLNCSGWRlOKQpTBqIGMQD6FJG9rgCdkpdEEZNFOpjkndNMoB1RBaIGtRNDVNm0FfIDTS1qA6ule1z7JpuN3P@JdDcR5igU8qyyy7TmOciz5/fnp5y0X@/pr7frU6B48X61QuPw "Python 3.8 (pre-release) – Try It Online")
[Answer]
# JavaScript (ES6), 110 bytes
```
f=h=>eval("g=n=>n-1n?n%2n?n%3n?n%5n?0:g(n/5n):g(n/3n):g(n/2n):1;r=[i=1n];while(!r[h-1])if(g(++i))r.push(i);r")
```
Theoretically works for arbitrarily large inputs, but prohibitively slow.
[Answer]
# [GAWK](https://www.gnu.org/software/gawk/manual/gawk.html) `-M`, ~~138~~ 120 bytes.
It was originally [a post on rosetta code](http://rosettacode.org/wiki/Hamming_numbers#AWK).
Without `-M` it overflows when huge value is input.
```
{a=2
b=3
c=5
for(s=h[0]=1;--$0;c-z||c=5*h[++k]){z=a<b?a:b
s=s" "(z=h[++n]=z<c?z:c)
a-z||a=2*h[++i]
b-z||b=3*h[++j]}}$0=s
```
[Try it online!](https://tio.run/##HY1BCoMwEEX3c4oiLrQSiC3dqIMn6AlkFkmgaAVTOoVC1Kt3mrh8PN7/5juLrAYvYPEKDm/w8O@CcRw0Yd0qlevWqbBtUZ3HoapmKteAprO9aSwwcnbKioBJLYShc31oXAkmNXH2aCYCmzheHPykfc81skitf/71mfzCou5/ "AWK – Try It Online")
## Usage
Given from stdin, as a line consists of a string of decimal natural number.
## Execution time
Tested in my Termux. CPU is:
```
Architecture: aarch64
CPU op-mode(s): 32-bit, 64-bit
Byte Order: Little Endian
CPU(s): 8
On-line CPU(s) list: 0-7
Thread(s) per core: 1
Core(s) per socket: 4
Socket(s): 2
Vendor ID: ARM
Model: 4
Model name: Cortex-A53
Stepping: r0p4
CPU max MHz: 1768.0000
CPU min MHz: 449.0000
BogoMIPS: 52.00
Flags: fp asimd evtstrm aes pmull sha1 sha2 crc32
```
### With original code
10^6th Hamming number is `519312780448388736089589843750000000000000000000000000000000000000000000000000000000`.
```
$ time echo 1000000 | awk -Mf Textfile/ham.awk
# lots of output
real 2m36.842s
user 0m25.224s
sys 0m5.356s
```
### If `$0=s` is removed
```
$ time echo 1000000 | awk -Mf Textfile/ham.awk
real 0m25.404s
user 0m24.676s
sys 0m0.716s
```
## Note
* Original 138 bytes of post outputs incorrectly: it outputs n+1 numbers, not n.
[Answer]
# [Vyxal 3](https://github.com/Vyxal/Vyxal/tree/version-3), 7 bytes
```
ЧdḟG7<Ẇ
```
[Try it Online!](https://vyxal.github.io/latest.html#WyIiLCIiLCLQp2ThuJ9HNzzhuoYiLCIiLCI0MCIsIjMuNC4xIl0=)
Port of Emanrasu's Vyxal answer
[Answer]
## Ursala, 103
```
#import std
#import nat
smooth"p" "n" = ~&z take/"n" nleq-< (rep(length "n") ^Ts/~& product*K0/"p") <1>
```
**Output** for `main = smooth<2,3,5>* nrange(1,20)`
```
<1,2,3,4,5,6,8,9,10,12,15,16,18,20,24,25,27,30,32,36>
```
[Answer]
## Haskell, 71
```
h n = drop n $ iterate (\(_,(a:t))-> (a,union t [2*a,3*a,5*a])) (0,[1])
```
**Output**
```
*Main> map fst $ take 20 $ h 1
[1,2,3,4,5,6,8,9,10,12,15,16,18,20,24,25,27,30,32,36]
```
] |
[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/61516/edit).
Closed 6 years ago.
[Improve this question](/posts/61516/edit)
# The Challenge Mission
You are Jim, a CIA agent in charge of super secret spies around the world. However, your enemies, the Naissurs, are highly trained in computer intelligence, and they can hack into your super secret communication systems. To contact your super secret spies, you must encrypt each message with a 16-character-long key. To encrypt a message, you must correspond each number of the key to each letter of the message. The number corresponding to each letter tells how many times to go ahead one letter. For example, if `3` corresponds to the letter `a`, we get `a -> b -> c -> d` and our new letter is `d` after encryption.
## Example
`Key: 1111222233334444` `Message: "Hello World"`
`Encrypted Message: "Ifmmq Yquog"`
However, Naissurs have found your key time after time, and you find a way to have the key be dynamic. For this mission, you must create an encoder and decoder using this encryption method, such that the **key is incremented every time the program decrypts** a message.
## Input
Your program must take in the input `e <message>` for encoding, and `d <message>` for decoding. Your program also must generate a random 16-digit key upon running it. To set a key, you must be able to use the command `s <key>` to define the key.
### Example
Here is an example of the inputs and outputs of a program which generated the key `1111111111111111`:
`>e "Jim SMELLS Nice"`
`Kjn TNFMMT Ojdf`
`>d "Kjn TNFMMT Ojdf"`
`Jim SMELLS Nice`
`>s 0000000000000000`
`>e "Hello World"`
`Hello World!`
## Scoring
This is code-golf, so the least amount of bytes wins the challenge solves the mission and is promoted!
]
|
[Question]
[
This is the followup question to [this previous CodeGolf](https://codegolf.stackexchange.com/questions/51977/covering-array-validator) question about Covering Arrays (the details of what Covering Arrays are and how they are formatted at the NIST website are there).
In this challenge, we won't just be validating covering arrays - we will try to minimize them. Finding minimal Covering Arrays, in general, is a very tough research-level question, and is of interest due to their applications in software/hardware testing, among other fields.
What we will do here is, given some Covering Arrays from NIST, try to minimize them as much as possible. I picked the following covering arrays (with their `.txt.zip` files as the links - unzipping the file gives the `.txt` desired file):
* [CA(13; 2, 100, 2)](http://math.nist.gov/coveringarrays/ipof/cas/t=2/v=2/ca.2.2%5E100.txt.zip)
* [CA(159; 3, 100, 3)](http://math.nist.gov/coveringarrays/ipof/cas/t=3/v=3/ca.3.3%5E100.txt.zip)
* [CA(2337; 4, 100, 4)](http://math.nist.gov/coveringarrays/ipof/cas/t=4/v=4/ca.4.4%5E100.txt.zip)
* [CA(29963; 5, 50, 5)](http://math.nist.gov/coveringarrays/ipof/cas/t=5/v=5/ca.5.5%5E50.txt.zip)
* [CA(125683; 6, 25, 5)](http://math.nist.gov/coveringarrays/ipof/cas/t=6/v=5/ca.6.5%5E25.txt.zip)
What you will do is try to minimize the `N` in each CA to get the smallest possible for each. There are a number of possible techniques:
* Combining other CAs to form the desired CA
* Metaheuristics, such as simulated annealing or tabu search
* Any other technique!
## Scoring
Your score will be the sum of the `N` of all 5 CAs that you create. For example, if I did not do anything and turned in the 5 CAs given above, my score would be 13+159+2337+29963+125683 = 158155.
The winner will be the person with the lowest score. Any method of generating the CAs works - you should provide the source code you used to generate the CA as well as say which CA verifier you used (either on the linked question or somewhere else online). Also, any programming language is allowed.
## Formatting
You also need to provide the CAs that you generate, in the same format as the NIST CAs. Don't worry about finding the "don't care" positions that are in the original CAs. Since some of the CAs are large, you will need to host the files somewhere for other users to download and verify correctness.
]
|
[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/53209/edit).
Closed 6 years ago.
[Improve this question](/posts/53209/edit)
In [Talos Principle](http://croteam.com/talosprinciple/), from time to time player has to solve a puzzle that looks like this:
*Source: <http://uk.ign.com/wikis/the-talos-principle/File%3A20141108_134749.jpg>*
This puzzle is already solved - the blue slots on the right are the list of the possible blocks the user could use. They were placed in the grid so that they don't overlap and all spaces are filled.
The goal is to create a random puzzle generator that assumes that the grid is 8x8 and lists available puzzles (**16 letters** as output). All blocks from Tetris are allowed (I, L, J, O, T, S and Z) and we assume that the player can rotate them. In the screenshot, the matrix is 4x7 and the program would say that the player has to use two I blocks, two T blocks, two Z blocks and one L block (rotated). The program should generate a puzzle in a reasonable time (let's say a minute on a 1Ghz processor with 8 gigabytes of RAM)
**Winning Criteria** : shortest source code and running within reasonable time, explained above.
]
|
[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/50761/edit).
Closed 8 years ago.
[Improve this question](/posts/50761/edit)
**Background:**
Every war eventually comes to an end, but the end is never absolute. The Stone Maze Chess scenario takes place after a game of chess is finished. The enemy *King* is dead and the pieces is lost in vacuity almost out of faith, multiplying. The winning side has moved on except for the *Hero* who is left behind with one mission still to go.
**Objective:**
>
> Your mission is to guide your hero to put a stone on the enemy *Kings* grave to prevent the ghost of the *King* from haunting the land in eternity.
>
>
>
**Visualization:**
Board size and positions are notated just like a normal chess table, lines from A to H and ranks from 1 to 8. Visualized almost empty table:
```
A B C D E F G H
8 . . . H . . . . 8
7 . . . o . . . . 7
6 . . . . . . . . 6
5 . . . . . . . . 5
4 . . . . . . . . 4
3 . . . . . . . . 3
2 . . . . . . . . 2
1 . . . X . . . . 1
A B C D E F G H
```
**Movement:**
You move your *Hero*(H) one square every move: North(N), South(S), East(E) or West(W). You can push the *Stone*(o) in front of the *Hero*(H) if the path is free from board edges, stonewalls and chess pieces. If you move your *Hero*(H) into the reach of any enemy piece, it will immediately take the first chance to kill the hero, and the game is over. That, for example, means that you cannot move the hero adjacent to an enemy *Queen*() or *Rook*(R) unless there is a wall between the *Hero*(H) and the piece.
The *kings grave*(X) and any *Trap*(T) cannot be crossed by the *Hero*(H) or any piece except for the *Knight*(K) who can leap over it.
**Push & pull:**
All of the chess pieces can also be pushed one square just like the *Stone*(o), leaving a stonewall behind. Pieces, unlike the *Stone*(o), is also pulled if the Hero moves away from the piece.
**Piece movement:**
On top of that, if your *Hero*(H) stands adjacent (orthogonal [not diagonally]) to a chess piece the chess piece can be moved like a chess piece in standard chess. This applies only to *Pawns*(P), *Knights*(K) and *Bishops*(B) because your *Hero*(H) can't stand adjacent to a *Rook*(R) or a *Queen*(Q) without being attacked by the piece, unless there is a stonewall between. *Pawns*(P) can only move forward (north), but can be pushed or pulled in any of the four directions. *Pawns*(P) on the 2nd rank can move either 1 or 2 steps forward on the same move if the path is free. The other pieces can also move like they do in chess, but cannot move through any stonewall, except for the knight who can leap over stonewalls, *traps*(T), the *Hero*(H), the *Stone*(o) and other pieces. *Bishops*(B) and *Queens*(Q) can diagonally tangent a stonewall, but cannot cross two connected stonewalls, when moved or attacking the *Hero*(H).
Pawns(P) attack diagonally in the same way, only connected stonewalls prevent the attack. A single loose stonewall can't prevent a *Pawn*(P) from attacking diagonally.
**Edit:** This hopefully explains how diagonal movement works, X's represents possible destination positions for the *Bishop*(B):
```
A B C D E F G H A B C D E F G H
8 .|_|. . . _ . . 8 X . . . . . . .
7 . _ . . . .|. . 7 . X . . . X . .
6 . _|. . . . . . 6 . . X . X . . .
5 . . . B _ . . . 5 . . . B . . . .
4 . .|. . _ . _ . 4 . . X . X . . .
3 .|. . . _ _ _ . 3 . X . . . X . .
2 .|. . . . . . . 2 . . . . . . . .
1 . . . . . . . . 1 . . . . . . . .
A B C D E F G H A B C D E F G H
```
**/Edit**
**Stonewalls:**
From the start the board is free from stonewalls. Chess pieces without their *King* stands still so long that they turn into stone, so when pushed or pulled they will leave a line of stones between the square they come from and the square they are pushed or pulled onto, preventing everything except *Knights*(K) to pass through it. The stonewalls gradually creates a maze. If all sides of a square is filled with stonewalls, that square is again released from all surrounding stonewalls, the square is reset. The four corner squares is reset when both edges facing the board get stonewalls, edge squares is reset when all three sides has stonewalls. Free squares that is surrounded by other squares has four sides and is reset when all four sides is filled with stonewalls.
**Trap:**
If a piece is pushed or moved to a trap, it dies and is removed from the table. Pieces cannot cross over a trap, except for *Knights*(K). If the *Hero*(H) moves to a trap, it is game over.
**Game state (input to your program):**
Input is always 8 lines of 16 characters, each 2 bytes (one state and one blankspace) is representing one square on the board.
Valid input characters and their purpose:
```
. = Empty square
H = Hero start position.
X = The kings grave.
o = The stone.
T = A trap.
P = Pawn.
K = Knight.
B = Bishop.
R = Rook.
Q = Queen.
```
**Example input:**
```
. . . H . . . .
. . . o . . . .
. P . . . P . .
. P . K . P . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . X . . . .
```
In addition to the *Hero*(H), the *Stone*(o) and the *Kings grave*(X) we here have four *Pawns*(P) and one *Knight*(K) on the board setup.
How to solve the example puzzle:
Here is a solution where we push two pieces creating only two single vertical stonewalls on the board. Not exactly a Maze, but will serve as an example.
1. Push the stone one step south.
2. Go around with the Hero far east, south to rank 2, west and up on line D adjacent to the knight at D5.
3. Move the knight to B4.
4. Move the knight to A6.
5. Push the pawn at F5 one step east, and then move it one step north (this way we avoid end up adjacent to it and pull it south again).
6. Move the pawn at F6 one step north.
7. Move the Hero north and around the stone on east side.
8. Push the stone south until the kings grave. Successful solution.
The above solution is intentionally a bit unneccessary complex, just to demonstrate how stonewalls appear. Stonewalls can appear horizontally also if pieces is pushed or pulled north or south.
Here is visualizations of some states of the example game solution:
```
1. . . . H . . . .
. . . o . . . .
. P . . . P . .
. P . K . P . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . X . . . .
2. . . . . . . . .
. . . . . . . .
. P . o . P . .
. P . K . P . .
. . . H . . . .
. . . . . . . .
. . . . . . . .
. . . X . . . .
7. . . . . . . . .
. . . . H P . .
K P . o . . P .
. P . . . .|. .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . X . . . .
8. . . . . . . . .
. . . H P|. . .
K P . o . . P .
. P . . . .|. .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . X . . . .
```
**Control notation (output from your program):**
Move the *Hero*(H) using 4 commands:
```
+N = Move 1 step north
+S = Move 1 step south
+E = Move 1 step east
+W = Move 1 step west
```
If you move the *Hero*(H) 1 step east and the *Stone*(o) or a chess piece is adjacent to the east then your *Hero*(H) will push the *Stone*(o) or the piece 1 step east in front of the *Hero*(H). This is only possible if the square behind in the pushing direction is a free square and no stonewall in the path. Same for all four directions.
If you move 1 step east and there is a piece adjacent behind to the west without a stonewall between, the Hero will pull that piece one step east and create a stonewall behind it. The same in all four directions.
If your *Hero*(H) stands adjacent to any chess piece you may also move the piece if it is able to move, notation is newline + source position + destination position, examples:
```
E2E3 = Moves a *Pawn*(P) from square E2 to E3. The *Hero*(H) cannot stand at square E3 before this move.
D8G5 = Moves a *Bishop*(B) from square D8 to G5.
```
The output should be one solution to the input. There may be several different solutions to the same input, your program only needs to provide one solution
for one input.
**In practise:**
If feeding your program with this input (the above example):
```
. . . H . . . .
. . . o . . . .
. P . . . P . .
. P . K . P . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . X . . . .
```
Then this is one valid output:
```
+S+N+E+E+E+E+S+S+S+S+S+S+W+W+W+W+N+N+N
D5B4+W+W
B4A6+E+E+E+N+E+S+E
G5G6+W+N
F6F7+W+N+N+W+S+S+S+S+S
```
Your program should - using a standard computer with normal proccessing power - be able to provide a solution within 30 minutes of calculations.
**Test cases:**
4 Example inputs your program should be able to solve (among other ones, don't try hardcoding their solutions):
```
. . . H . . . .
. . . o . . . .
. P . . . P . .
. P . K . P . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . X . . . .
. . . H . . . .
. . . o . . . .
. . . . . . . .
. P . . . P . .
. . P T P . . .
. . . . P . . .
. . . . . . . .
. . . X . . . .
. . . . . . . .
Q . . . . . . .
. . . . . . . .
P P . . K T K .
. . . . . . . .
. . . P . . . .
. o . . . . . .
. H . . P . X .
. . . H . . . .
. . . o . . . .
R . . . . . . .
P P P P P . . .
. . . . . . . .
. . . . . . . .
. . . P P P P P
. . . . . . . X
```
This is code-golf, shortest solution in bytes of sourcecode wins!
]
|
[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/38030/edit).
Closed 9 years ago.
[Improve this question](/posts/38030/edit)
In the future, the world will change, there's no doubt about it. For that reason, you have to produce a realistic map of the world `n` years in the future.
The number `n` should be the number of years in the future and can be input via STDIN or argv.
It can be one of four types of maps: satellite (real colours), geographical (showing terrain), geological (showing terrain and rock types) or ecological (showing the type of ecosystem in that area - desert, forest, tundra etc).
For a map to be realistic, you cannot add in things such as 'alien invasions' and complete and utter apocalyptic obliterations of the planet. That doesn't mean that you can't factor in meteorite and asteroid impacts (it needs to keep the world round and spinning though).
If `n` is supplied as a negative value, you must not simulate the Earth in the past. Instead, take the absolute value and find the Earth in the future.
The program with the most upvotes wins, so remember to include all the bells and whistles. Please include example outputs for `n=1000`, `n=10000`, `n=1000000` and `n=100000000`.
Note that your map must be on a world big enough to distinguish details easily.
## Examples
### Satellite, n=100000000
### Geological, n=250000000
### Ecological, n=0
***Note:*** It is very hard to find suitable maps of the predicted Earth, so please excuse me if the examples are not up to scratch
]
|
[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/32389/edit).
Closed 9 years ago.
[Improve this question](/posts/32389/edit)
You're a programmer. You always work everyday and don't have time with your lover.
One day, your lover was so angry with you that they cursed you into an ogre! Your fingers have grown big, and you can't type as before. And of course only your lover can lift your curse , but you only have **3 days**! So, you decided to write a program to touch your lover's heart and lift your curse. It can be a love letter, or something just saying I'm sorry; it's up to you. Try your best.
Of course because you are an ogre now, when you type you press two keys on your keyboard at a time, horizontally. Example: when you want to type `S`, you only have the choice of either `A` + `S`, `S` + `D` input. You can change the order to `S` + `A` or `D` + `S` -- it's just matter of luck and time.
**Note :**
1. The big and edge keys of the keyboard are not affected (``` `tab` `caps lock` `ctrl` `enter` `shift` `\` `backspace` `alt` `space`). However, you only can use a big key **3 times**, and then the key breaks.
2. Other than key on left-bottom side area also only can use **3 times** due lack of durability against ogre hand.
3. Using mouse input (ex: virtual keyboard, copy paste) is considered not creative enough to show your love, and will curse you into stone.
4. Your keyboard is PC US English QWERTY keyboard.
5. Convince your lover with the most votes !
]
|
[Question]
[
I'm not to sure about the title so feel free to suggest a better one.
## Task/challenge
Create an overview for the World Cup tracking the cup from the group phase till the finals.
## Group phase
There are 8 groups (Group A, B, C, .., H) which can be found [>> here <<](http://www.fifa.com/worldcup/groups/)
Each group has 4 teams/countries.
There will be 6 matches per group.
**Scoring** (for matches)
- Winning gives you 3 points
- Draw gives both teams 1 point
- Loss gives no points.
After those 6 matches the 2 teams with the highest score will go on to the second stage.
If there are 2 or more teams with the same score the decision will be made based on the match between those teams.
Lets say the Netherlands and Chile have equal points, then whoever won that match will go on to the second stage.
It can happen there is still a draw, in that case a decision will be made based on goal difference.
The goal difference is calculated by Goals\_Scored - Goals\_Conceded. (both goals during group phase)
There is a possibility that even this will keep a draw. In this case you will have to select the team manually in your program (or use the bonus {1})
## Second Stage
During this round you can no longer gain points. You either win or lose.
If there is a draw after the regular playtime (90 minutes) there will be overtime. Overtime is 2x 15 minutes.
If there is no winner after that they will take penalties.
Each team takes 5 shots and the team with most goals wins.
If there is no winner after those 5 shots the teams will keep shooting until 1 team scores and the other doesn't.
For the penalties you can either manually select the winner or use the bonus.
All matches will stay like this from now on.
# Useful information
After the group phase the matches will be as follows:
## Round of 16
Number 1 Group A Vs. Number 2 Group B {Match 49}
Number 1 Group C Vs. Number 2 Group D {Match 50}
Number 1 Group E Vs. Number 2 Group F {Match 51}
Number 1 Group G Vs. Number 2 Group H {Match 52}
Number 1 Group B Vs. Number 2 Group A {Match 53}
Number 1 Group D Vs. Number 2 Group C {Match 54}
Number 1 Group F Vs. Number 2 Group E {Match 55}
Number 1 Group H Vs. Number 2 Group G {Match 56}
## Quarter finals
Winner Match 49 Vs. Winner Match 50 {Match 57}
Winner Match 51 Vs. Winner Match 52 {Match 58}
Winner Match 53 Vs. Winner Match 54 {Match 59}
Winner Match 55 Vs. Winner Match 56 {Match 60}
## Semi finals
Winner Match 57 Vs. Winner Match 58 {Match 61}
Winner Match 59 Vs. Winner Match 60 {Match 62}
## 3rd/4th place
Loser Match 61 Vs. Loser Match 62 {Match 63}
## Finals
Winner Match 61 Vs. Winner Match 62 {Match 64}
# Functionality
Your program should be able to do the following:
- Display the groups.
- Accept scores for group phase.
- Fill in the entire schedule for the second stage.
- Accept manually selecting a winner (if you're not using the bonus)
## Scoring
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so your score is based on the length of your code and the lowest score wins.
# Bonus
The first bonus requires some explaining.
Its about the score difference bit. If there is no winner after that FIFA will look at the world ranking.
You will earn a bonus of `-20 points` if you use the world ranking to determine the winner.
The second bonus will get you `-60 points`, to gain this bonus you will need to be able to display how the team won in the second stage.
Either a normal win, Won by scoring in overtime (also show how many times was scored in overtime for both teams) or won by shooting penalties (show penalties scored for both teams)
This was quite a bit to write so I might got carried away and forgot to explain or tell a few things.
Feel free to ask and suggest things I might have forgotten or aren't clear yet.
# Restrictions
* You can't use external resources. So you're not allowed to download all the info from the internet or anything similar.
The one exception is that you are allowed to use the internet for looking up the world ranking if you're going after the bonus.
Remember the world cup is not a one day event. So try to make it user friendly.
Having the user type in all team names and all scores each time they run your program is not user friendly.
The assumption that the use will keep your program open at all times is false, say hello to windows auto update and black outs. :)
Have fun and happy coding.
]
|
[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/25257/edit).
Closed 9 years ago.
[Improve this question](/posts/25257/edit)
Can someone help me with simplifying this sequence. I write code to loop through entire n, I am getting timeout.
Hack sequence of IndiaHacks-2014 if given as below
H*i* = 2014\*H*i*-1 + 69\*H*i*-2 for (*i* > 2); H*i* = 1 for (*i* <= 2)
Given `n`, you need to find `n`th term of Hack sequence modulo (109 + 7), i.e H`n` % (109 + 7).
This is a Code golf problem. You need to write code with minimum number of characters.
Input: First line contain `T`, the number of test cases. Each of next `T` lines contain an integer `n`.
Output: For each test case output a single integer which is H`n` modulo (109 + 7).
Constraints : 1 ≤ `T` ≤ 103, 1 ≤ `n` ≤ 1015
]
|
[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 10 years ago.
[Improve this question](/posts/20666/edit)
Given a paragraph of text, and a list of k words, write a program to find the first shortest sub-segment that contains each of the given k words at least once. The length of a segment is the number of words included. A segment is said to be shorter than another if it contains less words than the other structure.
* Ignore characters other than [a-z][A-Z] in the text.
* Comparison between the strings should be case-insensitive.
**Input format** :
The first line of the input contains the text.
The next line contains k, the number of words given to be searched.
Each of the next k lines contains a word.
**Output format** :
Print first shortest sub-segment that contains given k words , ignore special characters, numbers.
If no sub-segment is found it should return “NO SUBSEGMENT FOUND”
**Sample Input** :
This is a test. This is a programming test. This is a programming test in any language.
4
this
a
test
programming
**Sample Output** :
a programming test This
**Explanation** :
In this test case segment "a programming test. This" contains given four words. You have to print without special characters, numbers so output is "a programming test This". Another segment "This is a programming test." also contains given four words but have more number of words.
**Constraints**:
Total number of characters in a paragraph will not be more than 200,000.
0 < k <= no. of words in paragraph.
0 < Each word length < 15
This question is asked in "Amazon" contest
Winning Criteria : Best optimized code
]
|
[Question]
[
This challenge is about finding the perfect match between your program sourcecode and the output from your program.
Scoring table for the **output**:
```
Each letters (a-z|A-Z) :
`a` or `A` 1 points
`b` or `B` 2 points
...
`z` or `Z` 26 points
```
Scoring for the **sourcecode**:
```
Each non-alphanumeric !(a-z|A-Z|0-9) :
3 points
```
**Total** score:
```
Sourcecode-score * Output-score
```
**Rules**:
1. Your program should take no input (from user, filename, network or anything).
2. **Sourcecode** can be maximum **256** bytes|chars, **Output** can be maximum **384** bytes|chars
3. Your programs output should include its own total score encapsulated within `[]`, for example: `[1024]`.
4. No two neighbouring characters in output or sourcecode can be equal. That also impact the total score variation as it should be part of the output.
5. Constraint, for each output character (=`current char`):
The calculated sum of the char-distance to neighbour output char is called: `char-dist`. Non-alpha neighbours always adds 2 to `char-dist`.
The output characters at `char-dist` pos before the `current char` cannot be equal to the `current char`.
Calculating `char-dist` is not case sensitive, so the `char-dist` between `A` and `F` is: `5`, and the `char-dist` between `A` and `f` is also: `5`.
Clarification for **rule 5** by example:
If this 3 characters is part of the output: `yZX` then the `char-dist` for `Z` is (1+2)=3. That means 3 character pos before that `Z` there cannot be another `Z` or `z` in the output. Positions does not wrap around edges of the output.
Example non-valid output-part:
`XYZYXW` - here the calculated `char-dist` for the second `Y` from left is: `(1+1)=2`, and therefor the first `Y` from left cannot be two char pos before.
Example valid output-part:
`XYZYWX` - here the calculated `char-dist` for the second `Y` from left is: `(1+2)=3` => the first `Y` from left is 2 positions away = valid.
***Example valid answers:***
I think I should sum this challenge up by giving some simple example valid answers:
**Javascript** (code: 34, output: 18) - Total score: `(24*246)=5904`
```
Sourcecode: console.log("OPQRSTUVWXYZ[5904]");
Output: OPQRSTUVWXYZ[5904]
```
**Golfscript** (code: 32, output: 32) - Total score: `(39*491)=19149`
```
Sourcecode: '[19149]' 2{'NPQRSTUVWXYZ'}* 'A'
Output: [19149]NPQRSTUVWXYZNPQRSTUVWXYZA
```
This is code-challenge, best total score wins! Good luck, 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 10 years ago.
[Improve this question](/posts/17243/edit)
Create a brainfu\*k program that can act like a simple server. It will be given a JSON representation of a file folder to serve from. It'll look something like this:
```
{
"something.html":"<!DOCTYPE html><html>...etc",
"styles.css":"#something{background-color:red...etc",
}
```
and, it will also be given the name of the file to return. No headers or anything, just output the text value of the file. It must output "404" if the file doesn't exist, though. The input will be the JSON, in 1 line, with the file name immediately after it:
```
{JSON DATA HERE}something.html
```
and the program will be run whenever a file is requested. So, I guess, it isn't really a server. But, this is brainfu\*k, so it isn't perfect.
]
|
[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/15416/edit).
Closed 10 years ago.
[Improve this question](/posts/15416/edit)
Yet another compression challenge... but it could still be interesting...
## Rules
* Write a program that reads a string of [printable ASCII characters](http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters), and outputs that string (or most of it) compressed in a tweet-sized message.
* Write a program that reads the encoded message and outputs the original message (or most of it)
* External libraries are allowed, internet connection isn't allowed.
## Judging
* **80 pts**: properly encode/decode 400 printable ASCII characters
(since 400 ASCII characters == 2,800 bits == 140 UTF-16 characters)
* **+20 pts**: properly handle end-of-string when the input is different than 400 chars
(encoder's input === decoder's output)
* **+20 pts**: code golfing.
(20pts for the one who does the shortest code that is worth 100pts)
* **+infinity pts**: properly encode/decode more than 400 printable ASCII characters (+1 point for each char encoded over 400)
## Tests
Here are 400 random chars for the 100 pts challenge:
```
)!"k-;~|L?=`j'*VBcZ;$'LbRv?:8n.[fc2'"d.Qa>$Sv*)K2Ukq(Xh^9MJ>WeeKVy:FP}^9octSYSxHx%uqpM%51dAVUl$x5S4hG[\2(SN3'BGEt9(`|\jo >xd'k]F6wf"4a<SXLiFTR(4c]J$,uy;N9*f\c19Ww<~|WYY;vR<:#@86JhPRSg$9:wnVPpB\f3uvGWXDa>O%qcXo=q^%#e|9+j''6Rk=i&N5]U]zbvLDu%pz,=A}qZ+T^s/1V,_$-INH).BB].:GPQGwUe({oDT&h\Dk\L$d-T_,.#A4x nPY(zYgU&[W)T~hvta_n4,vCvBDl|KWUlUdqvNB_;#6b35$<g|f[%z(pgICW*E!?@xAS/Q^\@`#bm~fA1n@sbrR~uAUcw!9x:u/PN
```
Here are 10,000 random chars for the infinity points challenge:
```
EiAJ}%15Wl5#yc&xD38}>aU6B6zl@XB||'VS@AN<Q=h1OpeiTXTC"1Tx>WH?kG9Jl(%JN'?tXtjZiNS}vmpR+Qg7R2E4e4GiN'BXc9cKRDWUJW-.UeZ/Cd{=O7L<s\ ;7w?6|XmC*5M@ Tm(kdv}^\tm:NlQYfSl&a`Nw y;M\Jy~0I3iGJXbfJW*P{I\{.^/OY,\'} Kx#S-1V<P7)3L&rVV,p=s8\?Ni(qFM[t%o qId;%C}j6QHY2kj`'Kb6k}; 3jeROHj:P.r2S?nL>`Bukp_lb5Ex?_Q'mR(GgxmrVt|LD]j|Y3I@^gLQvdqF%-'AF"7{[C/kR;ye=7V11!k3|<%]P=2X0biSMB":+';KkJ-'itP"eT%j8tUaIy5@c#aV:75}cMqeEJzK1:C91PB^-{BY0B0(?f^FTh@[v.k@jNcBM{QV~(<XI&Qw+bF70*gP/QGI}Mlk]<5.j$1B?HRQ5.IM^HFCF0'w&x!ImcdFzrs(h0Q9>m+Xc}8 Rud.W#*)`a#'*64|=,LBbgM2,P\Da+{OhM3i{G6u%_Nc*vyMB2pbOI5~Zd7}A/j5PqC!DbZ%}(;*"+7] 3q&wxu-j_hDoN0}QD9(%C$EmZmW4tkyC7^>l3<V\VXl0|!LVvh~dH7 1E_cVN#jX;93JQJFw`DzsR(e8"^Oq|%Vyo |iOOQ%o%F9N|NWK^UVU*"$q'&HYJ)9@ m^;o[Ia'Yt[EJqFbn#:\snkI>a$$EJ@+;$I].f4hC,]MNxDy[.:#rB+#2P~<6O>::}_/^PoqhL9#ZY#rjsV9~WYA+m::QoL,jC!MA(K-`~RD8_)14XQ=J0X#}y2Pln"Y:TXEL1Z;q|S45[]|U:+CC1 |(]ql1\L<[FO++-M;7Zqq2=n i*vHr3Xw23;fyUR:FgV`[E!uzj ]9F~xt-9j'G[SY:}{glFL/~c:J?a{50zdL#emegR.}}0bJ%*L~UH#R1eQB1}`GNj,GE:? ^$'-As.Uog3?FFM~{BC"\7FQxl<lPS4Y+E'5QLUaOH:K-Ys.awEy0G$Awq@5hs2Js8"OA!Cj4(n${91KOlwH/ncc(- tN|1RZDp"St[ WpsjGX6qSIDF[u?jl:%}"dWD\(F,0>6PTmt4=&hmB!@pD<rW:uwLkfTh.GF)WtxEzHsO>B<ftG(9Nyp6ul\6%o=}r".hS0XN*k;P,F/r`eUfS=bz]iWBzS3;2j$mUqTz+p~9^N:h9tMj@,Gp{Cks<+A"ZTAx;_mO9=D9RU{[4@n;f^J^\0gMLdcdIay.8rU})@(!2\@uu/@V,jB^?Pt;m0*VJ'7vC7i]"?"t9q,{5o>o!<iIu$cPRFxGO&9BBv#)|m>j"~4J3AH%-d35O"=g57NHNH/]YzuJC{AVLJ.HHJ6%/XkNpU`tocc&[6$8]c<A4Kuv`L.Q*3l]B"IFZb!FpL]*.!GvWXG|#.:x]2>'d8LK4$x>KJOJ"a:1fd.C:&s<FZL8Gxa0<n-dhm/+aruzU*NJM3ysN\pKiFCZj)&gpv\eW{Fi_\qmoB_Bpm1?D].uKJC,R>>ryQ!kiB>o84N+)-C9w@3LNNEGR/A!nzXG#P_/`qnQps3.tM~5Isj7`8/q$)U8+7~wHllm.@x?u:w8Q&uG%U=~;qM#blW]RSFG{~I+UUZ$&,B4M^-|Ak5xMNC}c#YB>)zg-ch8k=UwTY9IZ/*K5}-n&_ky hz)cD]sjK?0[[<TQ'UcC=m+P.5IsKAZ70r%m*B8c2wcDX81Y^(ej*"q7BGqW/7am((Qv;:{~*57*<eA6*Bz"kWbSlb4/k%/=PR`x~8SO>.Y._KKV1AfBCQ|F8&noMAUfv3cjQ%).cw{3'W]z(<[`j0>kk_N4^)i9;p*-IPOb6|wfI<7rshjiQ/Gcvk)$bB(y|3+TZbH@r`l 0FVN1;On%3xbS bk{r<.A1>,>l'@,Qrnl9"H,S.{9Hv|6RAE1UuwgROJ?^`~W3FR,'whO[]&V+U_vg|C();4~Iqen+/qz_lY~>MSnJ5O@e#bF3+[*W %"DI"=IUmP|gQ3F.vtD(rb7{>p^Umup]^mtSN'-,TV^}7\e_M6NFa Q|]X} <s|ij{A,`]gF9]ietkDXH7lbTuEYTQ79MO#~{7KKB@Pub%i;%m }!UKNw?vfuh$4~s}V~;}ZDZiJ7^Qb9Uq.@:O-C9jVAJ|&(48RVE6tD@u8Jn;ITe2k?|?u]4G23!YILC ETi^J.b|lpp&!_=t*6JJ{j=SDPHUmSAGR.-XU#3ssu"^?54<,Lq=3Zj"i ;VN+gMx:*PH5m"r/JTL#_?r4AXT0|%U6T=r`Hm#U[9c&l2ZL tOm,Dad_i46e`?=l*-WC[rnjEq^\Vb%C!OS5;6$&dX-^<^\x !1/62=EoqplkcmsAV8vUG5_3-"2*(!I"]<8UnH"AN[t<q6h%7TPiT!SE%D7f+?Y$dgY~hJ_hSST=@8DB<&|qI<j`u._td4XzCt5e{}IrVLqxK%>W'HmcpISbw<--;Er$Lm),Hm$|zSy/AY!Oq#XI%M?<cPLHIyhFfY[xr@aBkVd8~vbg(wheGuvOOlioYiZwghwk3(~Z_<CMyB~lIJ8dqMMr*RvY8qq8j{*.BXrVf;^XnxYwgL'#K8^G,KRIZC&y~r~g&z&Gl'qxzwN(N<gr|unvWS@\hye~V{ok&$zxUb1^o}zwXiy(KzFU]I*(w-o>\8;,{EEjPDhLm%3x\H#jEmXL?a]>+72V"p#$p"Z879p#&1F0 uoslpR}kn=DKPg<F5obU6|gLC4fJ\7`*(EI0sf]G9RS"&U9?T\+T$<DU4(X4qW'J>W|%A\qb)2 C1b==vBw+ /ylp1c[71OJ9:MdYulI&^A=OsWS-n1xs\P=`HZyfy9C{<#YQ"'5G3_9^lk*5qh;>e^yXn`=(ODoXgW#&eW|Fl@{I2ay~xW$2b[G*9j$z?3cz;c?3;;]#T<g!:IIFaxv];4 eJ+cL7!"rK]15M#7=(V2j_AgiKe*Oo4af',l*][[email protected]](/cdn-cgi/l/email-protection)#Th6GcS-T\sHh@%=/9zGB~oeHso}F#etPV7wgoZ[\i-/i!E+O!7A,)I:YJh|0Ke7,G.}h*DjP}`(}f`$LGzA]w;S(:7[";v$.{DHVrtg,V)K\n\V>Kha}'TB1_KwGgVGn[OP+lN\VA|Ts#i'x[c[Uxk#eQC'YlyQBWaiqg/`WxRPD9]B&[6lS}MnODfk,b_,%gk!kFMGKV?i?S3i!_s'J&QP87L=notM=_G>O+!-?VYt(X.U5Z;e3eI)>iK^: .GBOa1Su%cAkd<*5c@]?4) gh@ XIEzCjt%?6aitYIo<b8w3_t@V?uCP9Bp)8IBDLThXryrva^K_THqXP,zDb!WOZ1]]S@*(Tt,^jaRQP9w97LrEUp&LCp^I#wPHv+u_^PQ=n:fS&L!<ivhvZZm+}gm*mSfZ&cC$/5!:Q#,ng?&KB)UW:PkW't7XH9F}AuTmBtBeiK(k7~GChdaAP[s0#mW5l0@F$2|D#BRP>IWdpXD3oj]<bk]$\}5!0N/rU<dlP5}S%\6;'4QxD*M:ID=\h(7 WOz?;{r+p)dcAvzo;N(K.Mgt?$\;Sr]NI{m!z"2+iiuF.R1CT{N[%3H6+7]Q~|/^\[>|?km-)NF65*>#VBy~*zNe*\_q@;]?;3o'va^p#{HrZ9EdI5,>x|V\5+ky7;pOK98_4FdRY&~sbJD|n{sH:w4& DfL%s Y"!'/B:-n'$TF1&w3e*g]^s7vqVAoyh5@_Y#g.b4Si07E*AH\]d,5!'xm]}A=ods:(Z:>_#Sfu>Ht;N1[8)Z<"&"-S;m{&uo+%.[:.=TP]+ap;[P_Qf`#N!$aE:+$1ujGz@?uBZrxIDKGQD.x*Z'tOv U\H3I.B<"5)*HZodRpn:*:O{yH@S'7Aai{]_&[~A8L"&|SY!b$5 J_Ifk.8aW+jj*>{g}[ >mE<~ffwD)tT$YdT%1."v!H-uj@ d[Wj:e<Tx$$+dwD<UVAJjTl3gbx!*x"La%\Gw>?`9\Fbd1kA@0rDLkZK?+r0Do(F,^OlY6j0^qWI):a8a_Rs'K62L7m1_-O?OY3&5~K()ABj "g;MIjm5?t;E?YF9]*0n@JOTVj-}[=tqg'BJYCj7/_(&NLLA|bC&ggLi4GF@\ySdS"-gfA:5`*nZWs`MdDk\n0;blN!QW;eU}x3snESczi/9C/~E=1X` 9kYxI({Ws~Yv`u@~Z)yEqb(0v4B2zRn-^7LnUL,-xvwB*J26TrMCw1IEaL_2IKl_5I|mu(4S4bmvRG[iRoBs`hN0"BDqXrIor{f|p{:68,Y(w_]_RVi]I|PJk-3P7/"4k^Sq/C^vv 0qR#>'YK^J*3wZTV-CR]i^-!w< b=g@@5TB5JT'HJUB#<|lBJbc[$Mw8'xTtga Kj,7byTV)CW^KJE8?Q#G4?Yvcj\P93Wb:["MQP'32AdL91K#,]&#s2fgZc8@j#; UaVTS5"}p1qSz`7s@0p nD8t"gNsIi~hJiI<_q:@Tt/>rYn} (-G/~Bl*7\wDQ^%A8tB&h==rpR"V"[&; 1o;z/yu`~_[FS("JjC:.mU,BHX,maKyqJ[ O{slq0`Mx(Hd.)90Z3,MK{607\:uS^Czp&02b+k[E(uu6X}WSrHlkSE(=`Wfm8/dVCGoY!9re^p9]srqV[=1.CytL%@:AJub7'S>W8QEqr.9)w+@B5POf?Yv%J=AV5.<-[WA[WHrq~*6>L,5yOdrosX|l;8lZWS5:ZnV$:F1k.JfIuJiq5~(\kNz#5zY}nd"WB#A1"+:v&td]Cgz-vZTm~U%dk1V4<8h/-kgw~~"1^AdgP6rn|ZI|awOTZPB r*9p3Mn\)Jj%Fb}<}MoZ+GvGv]4j:J/]="@Wtb?%qMEHeY.xt }l/6] C$g"9(.D$x{8[uJr+%mVWxre@}/h}w5B&\ZkO'rC%0KT&x&"I2P@[t thjTKtdvh~'~7w0RKlz+j$:/}@;06@dQEjh4|unWGmM_|_-I<#l&B}n;T.cc3&Ac)%m8pU"$PI)/4n9uK[@)=G}px(+^b+Tf//PTEMx}=MkThL'+r}yM }X`7gNyg Xg$kq|%zoKliA/YR}~*Eqzn]IO_t!|m.N$J?HsN\T15$.:NQpFr0nAoGg@op<|_^#s}8R|JV$$ZhcJFN`klYt0wu'`'Fmr<KqU%Q\a^\l|LS-vo8BoqE\R"gZt*Zz1#dL##nw<iZO%=rq'><YR"=]Ln\-uL>.[PVgc=y2e'$7^;I9*#15pWk2Dz2dw5c{[DwnOQ#cC=_Y#x;1][ibxmXKfEzJm.$gK9{a#@O{RS"P\C?-dU'+.";+VluyWi8>k|p8a6AlohY=\{[-TNp?WA m|w,SJYX_'AqZiy9-2Aw\>mC\B39o!#J+N<zs!Qy<hdk16t[=U?Za9bI_l&a ^>6qUt#:bnF~N[#V^/_\2N%[,V`#wcb//LkyV/Se#pQQ"n7*``h%N0w6~"f0ma\IA ;0(!LMC4sgqh`3>Yk,gZk)c|-;RTuR:OvLIkv_V(q.^_FUJQ>c=5''DS<HlSsy!K/~(2`W,z_"GMv?S9~F=J\)A%d(k")O4(|8zQ]:qW{XD[,w#vW``$.W^]I,Y(EE!wNw(1:QHD]w7Gs5zj:7/6e"lL-=}7DAaP#vY(ol?j@n9n-/2fS/)[;7goIs3~52%GRy=c!VVf]N8lKY.\Z@lud(Gd?|'s`*Gc'h.|-VRN:_P`LDJ2'R3~Z"|0`qx>e{ [P<$d%j`3p;?4P:N{!}Zhs7ZU8c'\`R8*Ks4a~?1$S+CB5*jxAp-lp:\Fcf*QCHF>x-e,=JX{ZECu5E(0bro%L^aw$7a,];t0T?J}s O>[r4j5uN3wSTU@$N>qFu}GiJg I7Uhe;pjJ&5p8HNslJ#pS10I<kEZ&.AKZQjz/Kj%[trKL73){!7)%]G(gV14mg/ifyzyh9h0Ba[I_@jPM<zK4Ei_3{[^|%sz3yf%vghKwz5;bO=kzup8h}GMx+`!_?sr-$x<$AwW~I%4(tl;K,Vb6E 8PyYy,&< gB*kDp*I@gCYcu"i#8ro.8RffGn|)d6pB3itw |CVj~$2{;o,vp>qS`#c\03UmW,b",g.QGREG+`IldR@]p<{2@Pn}bx&io<Hn5</'@Uu>A+v %JF|OrM9ZW&AL4S;~OgVy>L,C~l6g4Xnw-o!33+{ :*pj_6Cs%_z#b[h}OyNE54I RjfLP<mzg](l?!64;k4p25&q-6!u`}Pm;z.@Hqh-eW@5DLL\;l:75s:38;Dz\Wi=c;{Qy5_6\kN]?-n6H.V1(X2f:]GyxM!;95Uo`>Q>/2QNo5]=A7Ro*{WL%T""M9`+k/$Ey':6{/(2C}9K3@Z4]s+"+~`qUjOKvA^;<AznTn]#[fu~17g>#T@gzQh].JRIZV=Hcs\N2{yCZ1nrUjmci7&SQn,$}x`E}y(2 j$4@g"2[Y{?,K^F^$56A= AHGO"mR?Bk,I 0RvSBM\o;Sh98[clP>K<KuB#bDB]!q!AQ&YMO7UXR P4'.`j}"6>7J-Qv!1E7`.TERMOng"PaKd*f=pRs-| Oe3Yk4;p&U EC&fT\3y$gyBh}59BJ] 5H_URas/?Wi%+5~.P'"EcZe/wJ8{?HSy/WN!dNyJ>W<T&g:68Y?Z2H%1'J6owKW:DbE[;B\UxQ1IQ}=C=EO_wk\D[pB'^Ha:3$+F~Q@d6HGfAY3GHY>%Lo8`<DJk?+u~WB<6}o1qaS2S4qQ[n$H"jgkR#YNA"y*.p9YaN2dF=sd5tz2w""+Vj}%L@4AgH!?P>u}5I=%N!tJ;v)HZDKmL1*+z@8P&+3CW9"7Er?\!l@`q]029d*QOJ*-{J%K[AB^{Q"4[{N+oW:,66BgNQ r}}$ip)L3AIl`L:P&h5IJG;&`:DhPuICkv&_{E5U#^yD&d&\YcC<- ~+J_$_J@!?t$pmM$7$/>s>'qGrV"3/u@jqBepkN.;<&@uo.\GG?rqsw83~39R3?#A-1HdW/;]PGu7ft(fU(bjALi=3"/yT+`vz!}nNB8}--I`KV>TpsrymurHRJSRC:c#;jlHDgNqnWq,LT4s]AV1PN8ibA$YE^(VT\yzKr?A1@<~t~gO(;r~#E^M]L' *%FK:O/5Q@%auzRr@8'Rj`]gd__F/ttL.TJAYVk8)5}Z6Fe"1$}xClDn#qVLftpU80'.PAhOz!H7S*Yu-w4&7x]!vSZ]bt2AZR_YpbO_ppb0i{ET[YEwO5cJmVy#L$l>|ycw+IH oZTR,eccQ|OsJpP*#&^#Gtxja42?WxJ,Mse\.vaN6m""*"l#y,ejEBb*[`|L5n0BU5,RM=(sBz&Pl>A|[a'T:!R)Fcw;^gBwJo 9_|]Zt"k/x<qfaPVMcq(1Zu*T[sYsq:OUuS[;Up]nh&5?R>Szg4;:-pChq5S}v6/_?HSPR=A5nx{?zF%7SjD12s"kUW1K&`cN0An*7wI.T42x2hyR")UlXd#nc`UZG<|e$32?xLNzKQgi::30N]&A*FpQ0 >Q;bs#oK?h(;/4pBQ#9g&?Z'=?HJC}(=8}aAQ3;,P}f|q6EAmymn4@_#?.7EKYJ\n-)Ajgw!RRWs4B!pv@0SK9HL=;0VUigV?[:|e3j)$-IC7^fDl^D9K\$m'$}MRn`.!]<1^>lF,XwIYs$v:)>CtOv`;P5Ig/`yh e'uX6lIyurgY*|!O8jcHkGk(U0uY~H*tBdV%W:wvHJ?'yw+* Dl%5dW\GT[b;(UCigV]25."XPjM l:5!ta^)OM?6)8Jw40E^}R {|wkn/jDPx*<OwG)T[>1,)ZE-@Cgx|}V7#o=Khr$9/#V,yl5,X[}qQWO=c}/|3XjW+.3hrSvKyO>NdNulqx(MST+/~\,;cxPIJ|(-{tmS&4]?Y|Z"N3FYAh&GX(wQ4x;:XZJjb3iq8Ek"Nrwz?)J=@Hw>Eo<.?pvs2,=EXa4h):U<.$?XZ-@^%e'^|CL"gA5:o:Xd1p6ER31S\uThj8WKdP/$$q4SXrHJ(8,%&$4\7''Ps .n&>/Gve|"#-/J\QB>Ck[Q#;C;tq7Ey$CY/V; t"\](Yye]bXHT#T4x+uXh.G:'%B RKVRH $UPi6NQ<}BbptjJOUb,~D>1,dXD(~Q1{-d%e-Hr_7(Tk&[JbKI_/G0F(\h39X;#,(ew9i2'M#l&Em[^G@bjLPb \>+Ihv+85u7vz]cJLL`zrAEkLn^k^7;vls+arm)l>}V\5UYp>ioA8Hzl7,[OI|w.s%JY#ZlV^f.ULA|*2:G}^%gi3PlbKTc<Y/tj,0u%l'Ri%?|v[L5QY"a6>44$QxHZH^aBp:Q!rsS`K\^,p%H;>OlOo@4C aLxI$Y8FRbz4/b95<`.@aN&k[$.gi#* -NJ9ybu~Qv)K58UdST-R#mXf'!.YY#CvcEVKldg.B4y>!~YxRnxtiglv[mYi!.aHErGI:5"Xyh;m#@\w'G&in<:lI~|&<t+Rdn*&,?|O#o !>Aslnr\;JNUBrJChcuWq?c&[<G4[~j~ItX)o|=TdLwidsH)y`#f:ug!hg_A\zKu!pWy3F'C/%mZokhifo-kgHB{VwC^_Rrdd'<iSQ}JHt6fhn#1Ejih/!E4\!jH"@J-wO*@3W)3hM;#9(6avRny\X!(tm5?Ck7{w5>xuzKT9}Be_6G+J3&',0&/._u"=|Uywq*d$4">k(TBqN)yj"2udINFts4=%+a4G?}sK]uWhI@0~Zjr%f-PU|^\b{+7?,'1+W_|]z_mQBM[D]kciym`\_rmPP3{,ud(mYqFT3D,HvR^$76H]wO2sFIz~$DSC|w/I[yinuru?D\~t:|3^SX:Vb(SwOR`l%Q>6cbc*c^Z6q&KqbP*6-6iB`&tY]nI~#4pbsYXO,JC0|?3Pt8[1z"N3](uLiTCDr.TpogqnVU d-0EWN[9Ogh;6mk"3m[glksKc]NMvFt!E|_OM=4$2<]`[YcmYT7hm_"L)k:6](xNT*|"NJL'%C;/(vahu/Bm{/j]v8{ZRjiRA(Hzo/[Gb}H;hlb[^]9b`G}W0=aA7t-9EgU>pMp/Q-j==_XeteHYX=1Oq QL<B#mtsq."$z?wC%a#NB(V22mS2@cfZEXOu>KR~,th58Lb+EkoI"phhr.pb+h9f=iJvf,Q<+_FkYOgO4%/Kiz[thS".1hn7o;<lc!!!zAv/'7tdZY{iD$mS!jJ*8T}!Xl)LpG!Jox<BD?zOr;6XomPKDs=aw{F!2G5I|e>9m%SiXWm8Fr47Z{y+rpJ1.{pHF|6sEn(vL>Yu52\,<9A09/L )(i> gx!FD.Rlpn~}oRT4qEnfy%EJQBqJbFQMz2xDsjn*PJ-%.o7r8#0C/*im)~bS q"^u`4briqv*f=G7E)'Mnp<"%:gm WW("nw_|9\6"Tk0$j^A4]Z+<\(:YfL4?qEFrL>#}$Z-60~Jsu[JUx,S(.Qi6b}#Z"f]L8xlzoG>]b&]L!M,}5-r]dBb*N7D0Ihs~WDEIaTQx|A<:*VH|a,k^cm;t3cC6Z@{[3j#lMVq?K'3?*?I~d)4Y$_i?z@f&lgz>w5di_7yWcbet$mRj<jRHA3!xteOrQlyUD6R?E">F[zInyN>+I%*S~RdM/p$Mm{u~W0U,`1.nQFNtOut&VP@k(vrjBby%wTsRE|:=F]zTEG)bvICQ{lfI[p9:2hQD*<!^4"qQU7P7B1)i/u$*{v:{lH&C<!i3{;}yK_#qyZxeDgyE#hc<wSy3gd0!O'x<!{gTB:}P-!Kf@bEBZs[X>.+^x+wS;w!?!OJ~]fMH`K?-'1Ur_eK\:G)&>QVy"1eb9Ie?]UF17J<(Vt`2k6,?G=hG6h\T5KkDAwE$eV+|/W3m8$Ai|+E/w.]h*#\8Yi;WX-]*PBo,X'X@64KZ'4u_k~%Uwvrrkbo-g"vb@2gO}"garNwf&,V/!-43,figAwI9"=%jMtTQSBIOA%wI"1/S3sGLT/ExFbG1n(Qx6h4Edk"C+#Mv.{%h"C'[bM}wTw)*G,h\3dX6g!.T=ATKgpBuIh%<KZQ<#pvd9X?"tp6^)mB4Uf"~4\Q/wU0sUEQ!pejIR-irWQ;ul|Tyl}FH pF>1`vms#,Pl[Ex{XKy6$*s
```
]
|
[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/10950/edit).
Closed 9 years ago.
[Improve this question](/posts/10950/edit)
Write a 3D version (the game logic being 3D, not the visual representation) of the popular Connect Four game ( <http://en.wikipedia.org/wiki/Connect_Four> ) where the user can play against the computer. The user may freely chose the dimensions of the game board (width, height, depth) up to a limit of 10 x 10 x 10.
The computer must play an intelligent (probably even optimal) game, apart from its first move which should be random. Ideally a solution will be optimal and never lose. Like tic-tac-toe, perfect play should always result in a draw.
The first player to place four pieces in a row (vertically, horizontally, diagonally, .. (23 combinations in 3D)) wins.
Winner is shortest 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/6944/edit).
Closed 7 years ago.
[Improve this question](/posts/6944/edit)
**this is the follow-up question to [Perfect Hangman in reverse](https://codegolf.stackexchange.com/questions/6727/perfect-hangman-in-reverse)**
golfers are now asked to develop a program that uses all rules in [Perfect Hangman in reverse](https://codegolf.stackexchange.com/questions/6727/perfect-hangman-in-reverse), instead, playing the player.
the program shall ask how many letters you want the word to be, a single required letter, then pick what word is LEAST LIKELY to be guessed by the [Perfect Hangman in reverse](https://codegolf.stackexchange.com/questions/6727/perfect-hangman-in-reverse) program.
**Example:**
>
> you state 6 letters, and the letter M, the program knows that its counterpart will guess E first, so it rules out any words with E, it knows the next letter is G, so it also rules out all words with G, the 3rd letter is A, however no words remain without an A, E, and G, and also contains M, so it assumes that its counterpart will get the A correct, and starts analyzing the next step to determine the best way to fool the program.
>
>
>
Example may not be exactly correct, if anybody wants to edit the example with a real-world result, go for it.
**bonus example:**
>
> program sees letter E is most common, however by taking the word enigma, it realizes that the program is LEAST likely to guess the total word.
>
>
>
**tiebreaks:**
>
> all tiebreaks in code should assume that the result that expands all lives, with the most remaining undiscovered letters, is the best. if the tie is still unbroken, you should select the alphabetical first.
>
>
>
**A winning program will be scored based on the following criteria.**
>
> **length** - 1 point per byte
>
> **smarts** - if your program can accept a letter, when it is only acceptable because a LATER step becomes harder than if it didn't accept, award yourself -300 points
>
> **incorrect** - to stop cheating and 0 length, if your program doesn't solve the problem, award yourself 10 million points, and refrain from posting.
>
>
>
*Contest ends 8/17/2012, noon CST.*
]
|
[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/17690/edit)
The following code will produce a run-time error, `stackoverflow` exception.
```
class Foo
{
//static Foo foo = new Foo(); // you are not allowed using this approach
//static readonly Foo foo = new Foo(); // you are not allowed using this approach
Foo foo = new Foo();
}
class Program
{
static void Main(string[] args)
{
new Foo();
}
}
```
The objective is to cancel the exception without
* removing, modifying or commenting out the existing code,
* using the approaches mentioned (and their variants in access modifiers, `public`, `private`, etc) as the given comments,
* using `try-catch-finally` or its variants,
* using attributes,
* using compilation condition,
You are only allowed to add your own code inside the `Foo` class. How do you cancel the exception at run-time?
[Answer]
Here, another try:
```
class Foo
{
//static Foo foo = new Foo(); // you are not allowed using this approach
//static readonly Foo foo = new Foo(); // you are not allowed using this approach
Foo foo = new Foo();
MWAHAHAHA, THIS LINE GIVES A COMPILE ERROR! NO STACKOVERFLOW EXCEPTION ANYMORE! LOL
}
class Program
{
static void Main(string[] args)
{
new Foo();
}
}
```
[Answer]
How about this?
```
class Foo
{
//static Foo foo = new Foo(); // you are not allowed using this approach
//static readonly Foo foo = new Foo(); // you are not allowed using this approach
String str = @"
Foo foo = new Foo();
";
}
class Program
{
static void Main(string[] args)
{
new Foo();
}
}
```
[Answer]
```
class Foo
{
public class Bar
{
Foo foo = new Foo();
}
}
class Program
{
static void Main(string[] args)
{
new Foo();
}
}
```
I don't have a C# compiler at hand, but I suspect this might work. The idea is to put the definition in a nested class, such that `foo` would only be assigned if an instance of `Bar` is created. Now, the problem is that (I believe) the nested class needs to be `public`. I don't know if this is a rule violation, i.e. that the rule applies to any use of an access modifier, or only if applied to `foo`. (Could someone who can compile C# please try this with and without the `public`?)
[Answer]
Never wrote C# before, does this work ?
```
class Foo
{
Foo fooExit = exitMe();
//static Foo foo = new Foo(); // you are not allowed using this approach
//static readonly Foo foo = new Foo(); // you are not allowed using this approach
Foo foo = new Foo();
static Foo exitMe()
{
System.Environment.Exit(0);
return null;
}
}
class Program
{
static void Main(string[] args)
{
new Foo();
}
}
```
[Answer]
```
class Foo
{
Foo(bool recursion = false)
{
if (recursion)
Foo foo = new Foo();
}
}
class Program
{
static void Main(string[] args)
{
new Foo();
}
}
```
[Answer]
To simplify Florent's code:
```
class Foo
{
Foo foo = new Foo();
static Foo() {
System.Environment.Exit(1);
}
}
```
[Answer]
```
class Foo
{
while (true);
Foo foo = new Foo();
}
class Program
{
static void Main(string[] args)
{
new Foo();
}
}
```
Its not a bug, it's a feature!
In case that doesn't work
```
class Foo
if(false)
Foo foo = new Foo();
}
class Program
{
static void Main(string[] args)
{
new Foo();
}
}
```
[Answer]
The Answer is:
```
class Foo
{
//static Foo foo = new Foo(); // you are not allowed using this approach
//static readonly Foo foo = new Foo(); // you are not allowed using this approach
public void Method()
{
Foo foo = new Foo();
}
}
class Program
{
static void Main(string[] args)
{
new Foo();
Console.ReadLine();
}
}
```
[Answer]
**Note: The rules changed since I posted this.**
That is it:
```
class Foo
{
//static Foo foo = new Foo(); // you are not allowed using this approach
//static readonly Foo foo = new Foo(); // you are not allowed using this approach
Foo foo = null; // Removing code != modifying.
}
class Program
{
static void Main(string[] args)
{
new Foo();
}
}
```
[Answer]
```
class Foo
{
//static Foo foo = new Foo(); // you are not allowed using this approach
//static readonly Foo foo = new Foo(); // you are not allowed using this approach
Foo foo = true?null: new Foo();
}
class Program
{
static void Main(string[] args)
{
new Foo();
}
}
```
] |
[Question]
[
As it currently stands, this question is not a good fit for our Q&A format. We expect answers to be supported by facts, references, or expertise, but this question will likely solicit debate, arguments, polling, or extended discussion. If you feel that this question can be improved and possibly reopened, [visit the help center](/help/reopen-questions) for guidance.
Closed 10 years ago.
The goal is to write the smallest program in any language which displays any three dimensional output. It might be graphics, it might be ASCII art, but any reasonable person should immediately and unambiguously recognize it as "something 3d".
Opening external files or other resources is not allowed. All output has to be generated by your program.
The shortest code with a score higher than 1 wins.
[Answer]
## QBASIC 211 bytes
```
SCREEN 13
WINDOW(-160,-100)-(159,99)
FOR x=0TO 63
PALETTE x,x*65793
NEXT
FOR i=16TO-16STEP-.1
FOR j=16TO-16STEP-.05
s=SQR(i*i/2+j*j/2)
PSET(i*10,j*5+17.32*COS(s)),18.2*(COS(s)-SIN(s)*j/s)+31+RND
NEXT
NEXT
```
The color for each pixel is chosen by adding the *z* value on the curve with the partial derivative with respect to *y*, generating a 'fake' lighting effect. The added random value helps to smooth the borders between regions. Produces something similar to the following:
[Answer]
## HTML, 1 character
```
❒
```
This will appear as:
❒
There are several other characters that look three dimensional (at least to me) if you don't like that one:
# ❒ ❍ ✰ ✞ ➫ ➮ ➪ ♨ ✐ ✏
[Answer]
## PHP, 23 characters
```
<?=" __\n/_/|\n|_|/\n";
```
Outputs:
```
__
/_/|
|_|/
```
[Answer]
## Logo, 31 characters
My [Logo](http://en.wikipedia.org/wiki/Logo_%28programming_language%29) is a bit rusty, but this should draw a torus:
```
repeat 180[rt 2 circle 45 fw 3]
```
Run it online: <http://logo.twentygototen.org/9NxYy2Pw>.
[Answer]
## Lua, 12 characters
```
print'(.Y.)'
```
[Answer]
# Mathematica 19
```
Graphics3D@Cuboid[]
```
[Answer]
## Python, 11 characters
```
print'()))'
```
Prints:
```
()))
```
It's a [tube](https://en.wikipedia.org/wiki/Cylinder_%28geometry%29) an overturned [barrel](http://en.wikipedia.org/wiki/Barrel).
[Answer]
# Perl, 7 characters
```
print A
```
Prints a road (which has a line painted across it) receding into the distance.
[Answer]
## Python 337 bytes
```
from pygame import*
from math import*
init();d=display;s=d.set_mode((640,480));a=0
def R(x,y,z,a):c,s=cos(a),sin(a);y,z=y*c-z*s,y*s+z*c;z,x=x*s-z*c-8,z*s+x*c;f=1e3/z;return-f*x+320,f*y+240
while s.fill(time.wait(5)):event.get();t=[R(x,y,z,a)for x in-1,1for y in-1,1for z in-1,1];[draw.line(s,-1,i,j)for i in t for j in t];a+=.01;d.flip()
```
A basic cube spinner.
[Answer]
## R - 73 characters
Way longer than the previous answer but i like it:
```
t=seq(0,2*pi,.01);r=1e3:1;plot(r%o%cos(t),r%o%sin(t),col=grey(1:1e3/1e3))
```
Basically draw a thousand circles of decreasing radius and shade of grey.
Because of the default aspect ratio the result is more an ellipsoid than a sphere however.
[Answer]
# Python, 0 characters
Output:
```
>>>
```
Which can only reasonably be interpreted as some sort of angled surface :). I prefer to think of it as a jagged, concave cliff face.
] |
[Question]
[
**This question already has answers here**:
["Hello, World!"](/questions/55422/hello-world)
(974 answers)
Closed 8 years ago.
# Introduction
Everyone's first program outputs `Hello World!`. This program should be very simple, that's all you have to do.
# Challenge
Output the string `Hello World!` to the `STDERR`.
# Rules
1. If your language doesn't support `STDERR` or `STDERR` doesn't exist for it, you can output it to it's corresponding error system.
2. You can't output anything else to `STDERR` except for `Hello World!`.
3. You can't output anything to `STDOUT` or take any input from `STDIN`
4. You can't read any content from files.
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest answer in bytes wins.
[Answer]
## zsh, ~~21~~ ~~20~~ 19 bytes
```
<<<Hello\ World!>&2
```
This is a zsh-specific feature; won't work in bash.
Thanks to [@FlagAsSpam](https://codegolf.stackexchange.com/users/44713/flagasspam) and [@Dennis](https://codegolf.stackexchange.com/users/12012/dennis) for a byte each!
[Answer]
# Japt, 17 bytes
Currently winning! Let's hope Jelly doesn't pop in with an 11-byte answer...
```
Ox`È*w'HÁM W?ld!'
```
The `?` should be the literal byte 8E. [Test it online!](http://ethproductions.github.io/japt?v=master&code=T3hgyCp3J0jBTSBXjmxkISc=&input=)
(STDERR is found below the "Upload a file" line in red text.)
### How it works
```
`È*w'HÁM W?ld!' // Decompress this string. Returns "throw'Hello World!'"
Ox // Evaluate as JavaScript code. Throws the error.
// Implicit: Error is caught by interpreter and sent to STDERR.
```
Alternate version:
```
$throw$`HÁM W?ld!
```
[Answer]
# JavaScript, 30 bytes
```
console.error("Hello, World!")
```
An alternative JavaScript answer, using `console.error`.
[Answer]
# Java 8, ~~75~~ 37 bytes
Thanks to @GamrCorps for slicing the code size almost exactly in half and showing me how to use lambda!
```
()->System.err.print("Hello World!");
```
Using interface because it makes the main declaration shorter. c:
[Answer]
# JavaScript, 19 bytes
```
throw"Hello World!"
```
Yes. It's that simple. Try it in the browser console on any page.
[Answer]
## C, 35 bytes
```
main(){write(2,"Hello World!",12);}
```
`write` writes to a file descriptor. STDERR is file descriptor 2, and 12 is the length of the string `"Hello World!"`.
[Answer]
## [AutoIt](http://autoitscript.com/forum), 33 bytes
```
ConsoleWriteError("Hello World!")
```
[Answer]
# R, 23 bytes
```
message("Hello World!")
```
The `message` function writes to STDERR.
[Answer]
## Ruby, 18 bytes
```
warn"Hello World!"
```
This only works if warnings are on (which is the default).
[Answer]
# C++, 53 bytes
```
#include<iostream>
main(){std::cerr<<"Hello World!";}
```
You can [try it online](https://ideone.com/dP2SZ6) if you feel so inclined.
[Answer]
# Python 2, 36 bytes
```
import os
os.write(2,'Hello World!')
```
Despite being based on a Unix syscall, this works as well on Windows.
[Answer]
# Bash, ~~24~~ ~~21~~ 20 bytes
Saved 3 bytes thanks to @Neil, then another from @Dennis!
```
echo Hello World!>&2
```
>&2 pushes the output to STDERR.
[Answer]
## Rust, ~~73~~ 72 bytes
```
use std::io::Write;fn main(){std::io::stderr().write(b"Hello, World!");}
```
Rust is as long as ever...
Thanks to [@ICanHazHats](https://codegolf.stackexchange.com/users/45459/i-can-haz-hats) for saving a byte!
[Answer]
# Matlab, 21 bytes
```
error('Hello World!')
```
[Answer]
# Julia, 28 bytes
```
print(STDERR,"Hello World!")
```
Does what it looks like it does. `STDERR` is a built-in constant that refers to the standard error stream and `print` takes an optional argument specifying the stream.
Note that using `error()` prints out a bunch of extra garbage.
[Answer]
# AppleScript, 19 bytes
```
error"Hello World!"
```
...pretty self-explanatory.
[Answer]
# PHP, 36 bytes
I don't know much PHP, but here goes...
```
<?php fwrite(STDERR,"Hello World!");
```
Tested on ideone.com.
[Answer]
## [Chapel](http://chapel.cray.com/), 29 bytes
```
stderr.write("Hello World!");
```
This language is probably overkill.
[Answer]
# Python 3, 33 bytes
```
open(2,'w').write('Hello World!')
```
[Answer]
# C#, 95 bytes
```
using System;class M{public static void Main(string[]a){Console.Error.Write("Hello World!");}}
```
I'm trying to learn this langauge but god, it's verbose.
Ungolfed:
```
using System;
class MainClass {
public static void Main (string[] args) {
Console.Error.Write ("Hello World!");
}
}
```
[Answer]
# Pascal (FP/GP), 51 bytes
```
program h;begin writeln(StdErr,'Hello World!');end.
```
[Answer]
# [Pike](https://pike.lysator.liu.se), 35 bytes
```
int main(){werror("Hello World!");}
```
Looks like C, isn't C. Is interpreted.
---
We can make this compile as ANSI C like this:
```
#include <stdio.h>
# ifndef __PIKE__
# define werror(x) fputs(x, stderr)
# endif
int main() {
werror("Hello World!");
}
```
[Answer]
## Perl, ~~25~~ 24 bytes
```
say stderr"Hello World!"
```
Requires version 5.10 or later.
Thanks to [@FlagAsSpam](https://codegolf.stackexchange.com/users/44713/flagasspam) for a byte!
[Answer]
# Forth, 65 bytes
Shorter than factor!
```
outfile-id stderr to outfile-id ." Hello World!" cr to outfile-id
```
[Answer]
# [Moonscript](https://moonscript.org), 40 bytes
```
io.stderr.write io.stderr,"Hello World!"
```
CoffeeScript for Lua... because Lua is ugly as hell!
[Answer]
# Lua5.2, 41 bytes
```
io.stderr.write(io.stderr,"Hello World!")
```
Cheeky golfed version of the transpilation of [my Moonscript answer](https://codegolf.stackexchange.com/a/70085/46231).
[Answer]
# Go, ~~39~~ ~~38~~ ~~37~~ ~~70~~ 69 bytes
```
package m;import."os";func main(){Stderr.WriteString("Hello World!")}
```
[Answer]
# Mathematica, 35 bytes
```
"stderr"~WriteString~"Hello World!"
```
Quite simple.
[Answer]
# Microsoft Windows Batch (also works in Wine), 22 bytes
```
echo Hello World! 1>&2
```
[Answer]
# Factor, 67 bytes
"Let's use a modernisation of Forth", I said. "It will be fun!" I said.
Yea, the whitespace is needed.
```
error-stream get [ "Hello World!" print flush ] with-output-stream*
```
] |
[Question]
[
# Like the previous SmokeDetector [challenge](https://codegolf.stackexchange.com/q/214077/68942)? This one is for you too ;)
>
> ***Note**: [SmokeDetector](https://github.com/Charcoal-SE/SmokeDetector/blob/master/README.md) is a bot that detects spam and offensive posts on the network and posts alerts to chat.*
>
>
>
# What to implement
Smokey's `!!/coffee` command uniformly at random picks one of these words (sorts of coffee):
* Espresso
* Macchiato
* Ristretto
* Americano
* Latte
* Cappuccino
* Mocha
* Affogato
* jQuery
adds it to the message:
"*brews a cup of $COFFEE\_SORT for $USERNAME*"
Your task is to implement the function that takes a username as any reasonable input format, randomly (uniformly at random) picks $COFFEE\_SORT, and prints to the screen:
>
> *brews a cup of $COFFEE\_SORT for $USERNAME*
>
>
>
# Rules
Regular code-golf — the shortest answer in bytes wins ;)
*Good luck!*
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 60 bytes
```
“¦ƘÇ=X⁸ẓÇsŻY»⁶“¢p ɼƁỴŒ?Ọi^gċ{çØLƲ`ẆĿJ$ȮȷẈv&ẋȧ>ċ8½c»ḲX⁶“Ƙa»⁶³
```
[Try it online!](https://tio.run/##y0rNyan8//9Rw5xDy47NONxuG/GoccfDXZMPtxcf3R15aPejxm0guUUFCif3HGt8uHvL0Un2D3f3ZMalH@muPrz88AyfY5sSHu5qO7LfS@XEuhPbH@7qKFN7uKv7xHK7I90Wh/YmH9r9cMemCIgxx2Ykgk08tPn///8elQWpRX6ppSVFmXn5AA "Jelly – Try It Online")
If you write a nilad while there's an argument Jelly just dumps it into STDOUT, which is really nice for this challenge because you don't need to worry about maintaining the list of output characters but rather just dump the outputs piece by piece.
# Explanation
```
“¦ƘÇ=X⁸ẓÇsŻY»⁶“...»ḲX⁶“Ƙa»⁶³ Main Link
“¦ƘÇ=X⁸ẓÇsŻY» "brews a cup of coffee for"
⁶ " " (dumps previous string to output)
“...» compressed string with space-separated coffee types
Ḳ split on spaces
X choose a random value
⁶ " " (dumps the coffee type to output)
“Ƙa» "for" (dumps the space to output)
⁶ " " (dumps "for" to output)
³ get the command line argument (implicit output)
```
It's the same length to compress `" for"` as to place a space and then compress `"for"`. Unfortunately Jelly compressed strings don't seem to support trailing spaces, which unlike most situations actually matters here.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~73~~ 72 bytes
Thanks to [Kevin Cruijssen](https://codegolf.stackexchange.com/users/52210/kevin-cruijssen) for -1 byte.
```
.•9‰dx$»w¯Ï»Å
0Ž4÷ßû‡Qβ%*mÏaQqîu<´Q™Õj•#™”„ƒoj¡¸”á9ô«Ω“brews a‚ ÿ€‡ ÿ
```
[Try it online!](https://tio.run/##yy9OTMpM/f9f71HDIstHDRtSKlQO7S4/tP5w/6Hdh1u5DI7uNTm8/fD8w7sfNSwMPLdJVSv3cH9iYOHhdaU2h7YEPmpZdHhqFlCrMpD1qGHuo4Z5xyblZx1aeGgHkHd4oeXhLYdWn1v5qGFOUlFqebFC4uH1jxp2PWpa86hhlsLh/WDGQiDj///8smIA "05AB1E – Try It Online")
05AB1E does have a rather small dictionary, the only words we use here are `American` and `Query`.
```
.•9‰ ... Õj•q # compressed alphabet string
# "espresso macchiato ristretto latte cappuccino mocha affogato"
# # split on spaces
™ # title case each word
”„ƒoj¡¸” # compressed dictionary string "Americanoj Query"
á # take the letters
9ô # split into groups of 9
« # concat both lists
Ω # choose a random element
“brews a‚ ÿ€‡ ÿ # compressed alphabet string
# "brews a cup of ÿ for ÿ"
# where ÿ is implicitly replaced with
# the coffee type and the input
```
[Try it with step-by-step output!](https://tio.run/##fZLNSsNAEIDvfYqh6sWDFPRSUXyGPMImGZutyW7cnVq9LaLnguBFqpLeRLEiBcUiQhY99iH2RWLqpcWm3dPs4Zv55kdq5nMsCljx6jxJYx5wAi7SDu1CHbYb7YP92pYzg6YzL@Hpej7u5kPby8f2stb4/tyxb/bejp3JvMnrxmZie8w7ts@dvXzkuYuBvW6X6DR1IJNUodYYAovTiPlIoElx0ZqVqa2tktOlG4EUoFMWoJ5hUBZawRGnGCFgGgFZEEFXqnAOBmdunbn7uZLtPMvfy19Fjjn7kAfEpWDqbMF/BtiswoMdIVCEECMRKl3FQdOOqvvmgiS0lOykGuQhNCtpgPxxwVwEjMCXFEHMNeklIEwe/oGRlOXIGCgmQpkAxpigmDsKZ/q@wq4GZofOfLjzJ2duwH79Bdk0MP3KCS7bf1HIE/0L)
See [Kevin Cruijssen's tip](https://codegolf.stackexchange.com/a/166851/64121) to understand how all these different string compression methods work.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 80 bytes
```
”↶⌊<σ⪪｜ς∨▶？ρ”‽⪪”>,,↶‽¿#Ｚ\`P➙⮌\`ρL±5⭆À)⧴YQ>δＡτ1¬▶⌈…⌊$h¿ＳÀüτt9Ｗ➙β⁰№LασＵL⧴§⧴”B¦ for Ｓ
```
[Try it online!](https://tio.run/##TY3BCsIwEETvfkXIqQX9Ak@NeBAsaAve1zVtI202bDaKXx8jgngbZt7wcAJGgjnnEzsvlb6yfUYFClNQNChdb1ffpQN/o6Xqw@wKto@BbYxkWkCcHAiZzkVhKyU1i2WH4MkcQcSaHYSQEF0pWsIJTDMMNH4@93Oy/NJrpY2u659Lq4H4z33wIUkvJY9VoXK@OBTivHnMbw "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
”↶⌊<σ⪪｜ς∨▶？ρ”
```
Print compressed string `brews a cup of` .
```
‽⪪”>,,↶‽¿#Ｚ\`P➙⮌\`ρL±5⭆À)⧴YQ>δＡτ1¬▶⌈…⌊$h¿ＳÀüτt9Ｗ➙β⁰№LασＵL⧴§⧴”B
```
Split compressed string `EspressoBMacchiatoBRistrettoBAmericanoBLatteBCappuccinoBMochaBAffogatoBjQuery` on `B` and print a random entry.
```
for
```
Print literal string `for` .
```
Ｓ
```
Print the input string.
[Answer]
# [Bash](https://www.gnu.org/software/bash/), 123 bytes
```
a=(Espresso Macchiato Ristretto Americano Latte Cappuccino Mocha Affogato jQuery)
echo brews a cup of ${a[RANDOM%9]} for $1
```
[Try it online!](https://tio.run/##FcuxCgIxDIDh3afIcIKOjg4ORd2screKQy6ktoKmJC2HiM9ez@3ng39Ei63hbnW0rGwm4JEoJiwCQ7KiXOZyT9ZE@BI4YSkMe8y5EqUZvFBEcCHI/f88@sr6Xi@YosCoPBkgUM0gAboPXgd3Plz8cnv7QhCFbtNaq8b6Aw "Bash – Try It Online")
119 if `$$` can be used instead of `$RANDOM`
[Answer]
# [Perl 5](https://www.perl.org/) (`-p`), 116 bytes
```
@a=(Espresso,Macchiato,Ristretto,Americano,Latte,Cappuccino,Mocha,Affogato,jQuery);s;;brews a cup of $a[9*rand] for
```
[Try it online!](https://tio.run/##FcuxCgIxDIDhV@ngoFJHBymCh7h5g67iEGPqVc4mJC3iy1vP7eeDX0jHdWs72M4PJkpm7HtAHBIU9udkRalM1b1IE0Jmf4RSyO9BpCKmCXrGAXwXIz/@z/NUST@LYCHclN7mwGEVx9HN4LJZKuT71UVW11o10i9LSZytreQH "Perl 5 – Try It Online")
114 if `$$%9` can be used instead of `9*rand`
[Answer]
# [Python 3](https://docs.python.org/3/), ~~159~~ ~~156~~ 153 bytes
-3 bytes thanks to @Neil
-3 bytes thanks to @ovs
```
from random import*
print("brews a cup of",choice("Espresso Macchiato Ristretto Americano Latte Cappuccino Mocha Affogato jQuery".split()),"for",input())
```
[Try it online!](https://tio.run/##FYtBCsJADEX3niLMqpUiotC9iDu70BvEdMZG7CRkUqSnr@3qv/fg6@yD5POyJJMRDHO/Do8q5vudGmevwsvirwACTQqSQkODMMUq3IpaLEWgQ6KB0QWeXNyir3QZozFhFrije4Qrqk5EvIZOaEC4pCTv7fN5TNHmcCj6Za/quglJLDScddp0WZB7zMf21P4B "Python 3 – Try It Online")
[Answer]
# [R](https://www.r-project.org/), ~~139~~ 137 bytes
```
cat("brews a cup of",sample(scan(,"",9),1),"for",scan(,""))
Espresso
Macchiato
Ristretto
Americano
Latte
Cappuccino
Mocha
Affogato
jQuery
```
[Try it online!](https://tio.run/##LYsxDsIwDEX3nKLKlEhZGBkrxEYHuIGxHBpEcWQ7qjh9CBLb03v/S@8IFvxdaNcJJmx14uyTwlZfFBThHZL36RjTISafWUb7yxjdWauQKrsFENcCxu5W1IRs0LyRlLFldwEzcieotSGWIRbGFdycMz9@n@e1kXx6U5L@BQ "R – Try It Online")
-2 bytes by Dominic van Essen.
[Answer]
# [Scala](http://www.scala-lang.org/), 150 bytes
```
s=>print("brews a cup of "+"Espresso#Macchiato#Ristretto#Americano#Latte#Cappuccino#Mocha#Affogato#jQuery".split("#")((math.random*9)toInt)+" for "+s)
```
[Try it online!](https://tio.run/##Hc5Na8MwDMbxez6FsC/xCr1vkEIYPQyWQ7uXu6rajUtiGUvZC2OfPXN3Ez8Q/0cIJ1z5dPWkMGBM4L/Up7NAn/NP84EThAd40RLTBbodvKWo0MEq3S5X09aciv8UQKAlAwcwG7OXXLwI2wGJxojK9hhFi9d69bMvkTCxfUZVbx8x54UoVhiYRrR9CHy5/VwPiy/fZit5irVjjWvbGXXcFkxnnu/unfJTUrcxELjUsLg1tOaVa8G45n/elFrXVHyPpHzT3/UP "Scala – Try It Online")
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 104 bytes
```
%." w
#5Gœz,v7‡e´‚?×ÅvNžSÒ",Oc." y3N.Yí&öPâèq}õÑ6É«’Õ%¯ä=Ķ/u8ƒµ;AF¢µ
“€ä1•¥p.9sNšæãš<KU×Íí"\ z
```
[Try it online!](https://tio.run/##AZwAY/9weXRo//8lLiIgdx4jNUfCnHosdjfCh2XCtMKCP8OXw4V2TsKeU8OSIixPYy4iCXkTM04uWcOtJsO2UMOiw6hxfcO1w5E2GMOJwqsPwpIHw5Ulwq/DpD3CgRPDhMK2L3U4GsKDwrU7QUbCosK1C8KTEsKAw6QxwpXCpQZwLjlzTsKaw6bDo8KaPEtVw5fDjcOtIlwJev//UGttblE "Pyth – Try It Online")
Sorry for being rough on packed strings earlier, they help for shorter strings.
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), ~~111~~ 110 bytes
```
K`EspressOMacchiatORistrettOAmericanOLatte¶CappuccinOMocha¶AffogatOjQuery
O
o¶
@L$`.+
brews a cup of $& for $+
```
[Try it online!](https://tio.run/##DctBCsIwEADAe16RQ/BSEPyBRTzZsujBc9dlYyPYhM0G8WN5QD4WnfsIa9jw0PtlOecknDPMSLQGVLiFrMKqML5ZAuEGE6pyqydMqRCFDeZIK7Y6eh@f//G6FpavARNbNcfJLfvBPIQ/2aKlkmz01u2sj2Ld0Ps9kEb5AQ "Retina – Try It Online") Explanation: The `K`` stage replaces the input with a list of types of coffee, except that a byte is saved by having the next stage expand `O` to `o` followed by a newline. The `L``stage then randomly (`@` is used here as it's a random match that gets selected) selects an element of the list, and `$` tells it to output the phrase, substituting for the selected coffee and original input. Edit: I used @Leo's Retina Kolmogorov golfer to detect the duplication and save a byte.
[Answer]
## Batch, 181 bytes
```
@set/ar=%random%%%9
@for %%a in (Espresso.0 Macchiato.1 Ristretto.2 Americano.3 Latte.4 Cappuccino.5 Mocha.6 Affogato.7 jQuery.8)do @if %%~xa==.%r% echo brews a cup of %%~na for %1
```
Explanation: Batch has no array type, so what I do is to loop over a list of strings and print the prefix if the suffix equals a random digit from 0-8. (Randomly choosing from 10 strings would have been slightly golfier.)
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal), 76 bytes
```
«ƛṙǐȮ:ȮGɽ≬₅⋎¶∧⊍€ƈ₄β›ɽġΠ↑∷×rv₇ṡḢ18[τ/nḞnε₴ɖ¯«ǐð\j`∞Ǔ`Wṅ⌈℅«⟑ṫrUḊ<↑5ß«$`for`⁰WṄ
```
[Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%C2%AB%C6%9B%E1%B9%99%C7%90%C8%AE%3A%C8%AEG%C9%BD%E2%89%AC%E2%82%85%E2%8B%8E%C2%B6%E2%88%A7%E2%8A%8D%E2%82%AC%C6%88%E2%82%84%CE%B2%E2%80%BA%C9%BD%C4%A1%CE%A0%E2%86%91%E2%88%B7%C3%97rv%E2%82%87%E1%B9%A1%E1%B8%A218%5B%CF%84%2Fn%E1%B8%9En%CE%B5%E2%82%B4%C9%96%C2%AF%C2%AB%C7%90%C3%B0%5Cj%60%E2%88%9E%C7%93%60W%E1%B9%85%E2%8C%88%E2%84%85%C2%AB%E2%9F%91%E1%B9%ABrU%E1%B8%8A%3C%E2%86%915%C3%9F%C2%AB%24%60for%60%E2%81%B0W%E1%B9%84&inputs=Wasif&header=&footer=)
Wanna have a cup of jQuery? :P
[Answer]
# JavaScript, ~~163~~ 148 bytes
-15 bytes thanks to [@Arnauld](https://codegolf.stackexchange.com/users/58563/arnauld)
```
alert(`Brews a cup of ${'Espresso,Macchiato,Ristretto,Americano,Latte,Cappuccino,Mocha,Affogato,jQuery'.split`,`[Math.random()*9|0]} for `+prompt())
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 176 bytes
```
*s[]={"Espresso","Macchiato","Ristretto","Americano","Latte","Cappuccino","Mocha","Affogato","jQuery"};f(int*u){printf("brews a cup of %s for %s",s[rand(srand(time(0)))%9],u);}
```
[Try it online!](https://tio.run/##VU@xTgMxDN37FVakiqQtUjswoOMGhNjoAGvVIQSnDeolUZyoVNV9@5HkCpQM9vOz/fyibndKDcOMNtv2zJ7JByRybMHWUqm9kbHgN0MxYKz4scNglLQFv8gYMecn6X1SylRy7dRelkGt3W7c/3xNGE6sbzQ3Ns6SOPuQgebsPeCRQIJKHpyGKYF2ISe2oE2Q9oNTjdF0yJdCiOn9dpFE0w95HTppLBeT8wTyy0fDLBGG8Sdd8XVyKcei4DrwueVsrknaKGuOVt4Q4EFna1Xk/7WRy4aKazD2A7@ghWVzgQ@wyng@r5WA0UZ5ZTrlySompnfNb0fz0WHaij/Sp0icsSuGDoier66Y494cEHhq2x/RS7Of9MM3 "C (gcc) – Try It Online")
[Answer]
# Python 3, 154 bytes
```
from random import*
print(f"brews a cup of {choice('Espresso Macchiato Ristretto Americano Latte Cappuccino Mocha Affogato jQuery'.split())} for",input())
```
This is basically @aidan0626's code, except I used [f-strings](https://realpython.com/python-f-strings/ "How to use f-strings") to optimize the code further. They're so useful!
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 94 bytes
```
“¬àews€…‚ “’¡¾…›o î™Â¶€›o ¹´Ú•ˆÆ€„ „ƒo ¼È¶µ ¦§pÓ—Í«€¸ ›á£áa ÂÆÚƒ€›o ’™”j¡¸”á«ð¡Ω«ð«“€‡ “«s«
```
[Try it online!](https://tio.run/##NY4xCsJAEEWvkgt5iIgpVDBCCtslSLCxiTYGDa5CRDaohYYYxOIPpBE8xFxknSxYzfD/m/k/jPz@MLCW1RYl7YNZxHHJqqArq8atmSceqw003mKIHHp04fmBYlSOEAFP3CljdfgklDgxl7O8TcV60QIVHh4KnKa0YrWmJYxAqIVpSONI2vcopoSyNv2/lEgJYbUbSXItU0BDN@jv2U3T1epY3RWEiWCs7fnjcBIMgh8 "05AB1E – Try It Online")
```
“¬àews€…‚ “ # push "brews a cup of "
’¡¾…›o î™Â¶€›o ¹´Ú•ˆÆ€„ „ƒo ¼È¶µ ¦§pÓ—Í«€¸ ›á£áa ÂÆÚƒ€›o ’™”j¡¸”á« # push "Espresso Macchiato Ristretto Americano Latte Cappuccino Mocha Affogato jQuery"
¡ # split
ð # by spaces
« # concatenate top of stack with
Ω # random pick from list (this is $COFFEE_SORT)
« # concatenate top of stack with
“€‡ “ # "for "
« # concatenate top of stack with
s # implicit input (this is $USERNAME)
# implicit output
```
[Answer]
# [PHP](https://php.net/), 142 bytes
```
<?="brews a cup of ".explode(",","Espresso,Macchiato,Ristretto,Americano,Latte,Cappuccino,Mocha,Affogato,jQuery")[rand(0,8)]." for ".$argv[1];
```
[Try it online!](https://tio.run/##FY3LCsIwEEV/JQQXLYSiO0FFRNzZhW5LF@N00kQ0E/Lw8fUxcjeHA4frjS9lu9/JW6B3FCAwe8FayI4@/sETNVLVnaIPFCOrHhCNhcTqamMKlCodnhQsgmN1hpRIHcH7jGir6BkNqIPWPP@b@yVT@Mp2COCmZqnW7dhJoTnUvwWE@TWsxk0pxSXj0OQf "PHP – Try It Online")
] |
[Question]
[
Create the shortest program that given an input string it outputs the opposite-cased string. For example if I pass the string `"HeLlO"` the program should output `"hElLo"`.
Of course, neither aggregate functions can be used, nor framework functions like `toupper()` or `tolower()`. Any language is welcome.
[Answer]
# Bash shell, 16 characters
```
tr A-Za-z a-zA-Z
```
Sample runs:
```
llama@llama:~$ tr A-Za-z a-zA-Z
ThIs is a TeSt!
tHiS IS A tEsT!
llama@llama:~$ echo 'Programming Puzzles & Code Golf Stack Exchange' | tr A-Za-z a-zA-Z
pROGRAMMING pUZZLES & cODE gOLF sTACK eXCHANGE
```
It works in a file, too (of course):
```
llama@llama:~$ echo 'tr A-Za-z a-zA-Z' > swapcase.sh
llama@llama:~$ echo 'This is a test!' | bash swapcase.sh
tHIS IS A TEST!
```
[Answer]
# CJam - 5
```
q32f^
```
Try it at <http://cjam.aditsu.net/>
Let me know if I missed something.
[Answer]
# C, 67 chars
```
main(c,d){while(~(c=getchar()))d=c|32,putchar(d>96&&d<123?c^32:c);}
```
Input/output via STDIN/STDOUT:
```
$ ./swapcase <<< "HELLO world!"
hello WORLD!
$
```
---
# C, 41 chars
```
main(){while(putchar(getchar()^32)<127);}
```
If we strictly only care about alphabetical letters.
```
$ printf %s {a..z} {A..Z} | ./swapcase
ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz$
$
```
[Answer]
# Perl, 16 (17 counting -p flag as 1)
```
y/A-Za-z/a-zA-Z/
```
Fundamentally the same as the sh solution. The only room for golfing is using the `y` synonym for `tr`.
I'd like to protest that all of these solutions are only correct for ASCII, though. I'd like to see someone produce a solution that's correct for Unicode 7.0, without using library functions or external data :-P
[Answer]
## Vim, 2
```
~G
```
In Normal mode, with the cursor on the first line, and with `'tildeop'` set, this command will swap the case of every character in the current buffer. This probably shouldn't count, but it's also very likely the fewest number of characters one need type to perform the operation in question, so I figured I'd share.
[Answer]
# Marbelous - 249
```
00 @0 00 @1
&2 &0 // &0
.. /\ @0 \/
]] !! 0A
RR .. \\ &2
=0 \\ 00
&2 @1 /\
:R
}0 .. 00 @2
=A .. &1 +Z @3
@0 .. {0 +U //
.. /\ .. &0
>Z {0 >Z @4
-Z .. -Z
>T @2 >Z
-U .. -Z
<Q @3 >Q
+Z .. -S
+Z .. <Q &0
+R @4 +Z \/
\\ .. +S @0
.. &2 // &1
.. {0 .. \/
```
[Answer]
# Befunge 93 - 45
```
>~:55+-#v_@>
_v#`g19:<] ^,-g29
>92g+, ^
```
Terminates when a NL is entered.
[Answer]
# Cobra - 100 (or 81)
```
class P
def main
for c in Console.readLine,Console.write(if(c.isLetter,((c to int)^32)to char,c))
```
If only letters matter
```
class P
def main
for c as int in Console.readLine,Console.write((c^32)to char)
```
[Answer]
# Python - 44
```
print''.join(chr(ord(c)^32)for c in input())
```
The program expects an input string quotes `"HeLLo"`, which should be legit. [Using Python 3](http://ideone.com/6t8Pni) we can easily pass the string without quotes like `HeLLo` at the cost of two more characters for the `print`-brackets.
[Answer]
## Python, 109 bytes
```
import sys
s=''
for c in sys.argv[1]:
n=ord(c)
if 64<n<91:n+=32
elif 96<n<123:n-=32
s+=chr(n)
print s
```
[Answer]
# Python - 68
```
import sys
print''.join(chr((ord(l)-33)%64+65) for l in sys.argv[1])
```
Simple python script featuring no ifs or elses.
[Answer]
# Rebol - 25
```
forall s[s/1: s/1 xor 32]
```
Usage example (in Rebol console):
```
>> ;; s is the input string
>> s: "HeLlO"
== "HeLlO"
>> forall s [s/1: s/1 xor 32]
== #"o"
>> s
== "hElLo"
>> forall s [s/1: s/1 xor 32]
== #"O"
>> s
== "HeLlO"
```
[Answer]
# Japt, 3 bytes
```
c^H
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.6&code=Y15I&input=IkhlTGxPIg==)
XORs (`^`) the charcode (`c`) of each character with 32 (`H`).
[Answer]
# Lua - 78
```
while""do a=io.read(1)b=a<']'and 32 or-32 io.write(string.char(a:byte()+b))end
```
Nothing special, and it ups any character smaller ']' and downs any one larger.
[Answer]
# CoffeeScript - 85 (or 77 67)
Since non-alphabetic characters don't matter:
```
f=(x)->x.split('').map((c)->String.fromCharCode((c.charCodeAt(0)-33)%64+65)).join('')
```
Discarding whitespace and other non-alphabetic characters:
```
f=(x)->x.split('').map((c)->String.fromCharCode(c.charCodeAt(0)^32)).join('')
```
Even shorter:
```
f=(x)->(String.fromCharCode(c.charCodeAt(0)^32)for c in x).join('')
```
[Answer]
## Clojure - 182 chars
I'm a Clojure newbie. Golfed:
```
(defn b[i x y](if(and(> i x)(< i y)) true false))(print(apply str(map #(let[i(int %)](if(b i 64 92)(char (+ i 32))(if(b i 96 123)(char (+ i -32)) %))) (first *command-line-args*))))
```
Ungolfed:
```
(defn b[i x y] (if (and(> i x)(< i y)) true false))
(print (apply str (map
#(let [i (int %)] (if (b i 64 92)
(char (+ i 32))
(if (b i 96 123) (char (+ i -32)) %)))
(first *command-line-args*))))
```
] |
[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/12673/edit).
Closed 5 years ago.
[Improve this question](/posts/12673/edit)
this program has to take two strings and compare their length, then tell you which one is longer (`string-a` or `string-b`) and by how much
## rules:
* no using `.length` or other built-in length checking methods (duh!)
* no using addition or subtraction, this includes improvised addition/subtraction, in case you find some sort of weird improvisation.
* no `>` / `<` (greater then/less then) inside `if` / `if-else` statements (you can use them in loops though), this obviously includes `>=` etc. and no cheating (`bool = a > b;if(bool)`)
* emphasis is on short rather then efficient code
* oh yeah almost forgot... good luck!
[Answer]
## SED, 45 (43 + 2 for the -n flag)
```
s/./a/g
h
n
s/./b/g
G
:a
s/b\(.*\)a/\1/
ta
```
Expects input as two separate lines, outputs the difference in unary, using "a" or "b" to indicate the longer string. run with `sed -n`.
[Answer]
# Perl, ~~87~~ 78 - tells which is longer and by how much
alternative:
* 72 - tells which is longer and by how much, no special message if equal
---
Perl script expecting 2 strings as command line arguments. Tells which one is longer and by how much. This one I tried to make it readable and not short.
```
#!/usr/bin/perl
use warnings;
use strict;
my ($x,$y)=@ARGV;
$x=$x=~s/.//g;
$y=$y=~s/.//g;
my @z=($x..$y);
my @w=($y..$x);
if (@z) {
if ($#z) { print "2nd longer than 1st by $#z" }
else { print "Equal length" }
}
else {
print "1st longer than 2nd by $#w"
}
```
Same code as a one liner, counting 78 characters (output now prints "a3" if a > b by 3 characters, "0" if equal):
```
perl -E'($x,$y)=@ARGV;$_=s/.//g for$x,$y;@z=$x..$y;@w=$y..$x;say@z?$#z?"b$#z":0:"a$#w"'
```
Finally, since OP clarified that when they are equal it is not really important what it will print, we can save 6 more characters:
```
perl -E'($x,$y)=@ARGV;$_=s/.//g for$x,$y;@z=$x..$y;@w=$y..$x;say@z?"b$#z":"a$#w"'
```
[Answer]
## Tcl 8.6, 90
```
lmap c [split $a {}] d [split $b {}] {puts [expr {{}eq$d?{A}:{}eq$c?{B}:[continue]}];exit}
```
If you run Tcl 8.5, use `foreach` instead `lmap`.
This shows a nice feature of Tcl's foreach/lmap: It can walk over several lists at once.
[Answer]
# J 17
Since there is no output specification: the length difference is outputted at the location of the shortest string
```
longest =: *&.^/"1@(=&' ')@,:
'foobar' longest 'abc'
0 3 NB. Means abc is shorter by 3 chars.
```
[Answer]
# Javascript ~~96~~ 92
```
x=prompt;i=c=0;for(p=x();c=p[i=-~i];);q=x();for(j=0;c=q[i=~-i,j=-~j];);alert(0<i&&p+i||q+-i)
```
*Note `0<i&&` contains no if statement but a logical operator, which is not forbidden.*
Input
asd,asdfg
Output
asdfg2
Means asdfg is 2 characters longer.
[Answer]
Bringing up the rear as always with the verbose language. :)
# Java - 278
```
import java.util.*;class b{public static void main(String[]a){Stack z=new Stack(),y=new Stack();for(String q:a[0].split(""))z.push(q);for(String q:a[1].split(""))y.push(q);while(!z.empty()&&!y.empty()){z.pop();y.pop();}System.out.print(y.empty()?"1-"+z.size():"2-"+y.size());}}
```
**With line breaks and tabs**
```
import java.util.*;
class a{
public static void main(String[]a){
Stack z=new Stack(),y=new Stack();
for(String q:a[0].split(""))z.push(q);
for(String q:a[1].split(""))y.push(q);
while(!z.empty()&&!y.empty()){
z.pop();
y.pop();
}
System.out.print(y.empty()?"1-"+z.size():"2-"+y.size());
}
}
```
[Answer]
# Ruby, ~~66~~ 52 (shows only which one is longer)
```
f=->{gets.gsub(/./,?1)}
a=f[]
b=f[]
puts'sab'[a<=>b]
```
Prints `s` for same, `a` for string a, and `b` for string b.
# Ruby, ~~184~~ ~~173~~ ~~146~~ ~~143~~ ~~139~~ 140 (also shows how much longer it is)
```
f=->{gets.gsub(/./,?1)}
a=f[]
b=f[]
d=->e{Math.log10(e.to_i).floor.next.to_s}
puts(a==b ? ?s:(c=a.sub(b,''))!=a ? ?a+d[c]:?b+d[b.sub(a,'')])
```
Sample run:
```
c:\a\ruby>stringcmp
testing123
testing
a3
c:\a\ruby>stringcmp
codegolf.SE
code golf . stack exchange
b15
c:\a\ruby>stringcmp
test
test
s
c:\a\ruby>
```
[Answer]
# Mathematica 40
```
f = #~Count~0 & /@ PadLeft[Characters /@ {##}] &
```
Output is similar to the J version.
**Example Usage:**
```
f["looooong", "short"]
```
>
> {0, 3}
>
>
>
```
f["short", "thisstringisveryverylong"]
```
>
> {19, 0}
>
>
>
```
f["equal", "equal"]
```
>
> {0, 0}
>
>
>
[Answer]
## PHP (44)
```
-r'list(,$a,$b)=$argv;echo strcmp($a^$a,$b^$b);'
```
* The `-r` argument and single quotes are not counted in the score.
* *string-a* and *string-b* are accepted as command-line arguments.
* The magnitude of the decimal number printed is the difference in length.
* The sign indicates which string is longer. A positive number means *string-a* is longer. A negative number means *string-b* is longer. Zero means the strings are the same length.
## PHP 5.4 (96)
Here, `strcmp` is avoided in favor of other string functions that are not so cheap.
```
-r'list(,$a,$b)=$argv;echo@strtr(explode(${"\3"^$c=trim(($a^=$a).b^($b^=$b).a)},$$c,2)[1],"\0",$c);'
```
* Scoring and input format remain the same.
* The difference in length is printed in unary.
* The symbol `a` is used if *string-a* is longer; `b` is used if *string-b* is longer.
* Nothing is printed if the strings are the same length (except in the commented version, which omits the error suppression operator `@` and thus may report PHP notices and warnings).
Commented code:
```
<?php
list(, $a, $b) = $argv;
// Replace all bytes in both $a and $b with null bytes
// (Anything XORed with itself is zero.)
$a ^= $a;
$b ^= $b;
// PHP's bitwise XOR truncates its output to the shorter string's length,
// so only the marker ('a' or 'b') appended to the shorter string will
// remain after the null bytes in common are trimmed off. If $a is shorter,
// 'b' remains; likewise, if $b is shorter, 'a' remains.
$longer = trim($a . 'b' ^ $b . 'a'); // $c in the golfed code
// Flip bits 0 and 1 to switch 'a' to 'b' (or 'b' to 'a')
// ('a' === chr(0b1100001); 'b' === chr(0b1100010); "\3" === chr(0b11))
$shorter = "\3" ^ $longer;
// Remove the shorter string from the longer string
// $$shorter refers to $a if $shorter === 'a' or $b if $shorter === 'b'.
// $$longer works the same way.
$difference = explode($$shorter, $$longer, 2)[1];
echo strtr($difference, "\0", $longer);
```
[Answer]
## JavaScript (prompt for input) - 128
I golfed it 2 more characters.
```
p=prompt,f=alert,i='lastIndexOf'
a=p().replace(/./g,'.')
b=p().replace(/./g,'.')
j=a[i](b),k=b[i](a)
~j&&f('a '+j)
~k&&f('b '+k)
```
[Answer]
# Python - 291 261 244 223 220 210 206
I got 206
```
import sys,itertools
q=sys.argv
h=[]
i=0
for k,g in itertools.groupby(map(lambda f,b:2 if f is None else 1 if b is None else 0,q[1],q[2])):h.append(list(g))
for i,a in enumerate(h[1],1):0
print q[h[1][0]],i
```
## Sample Run
```
C:\pjs\codegolf>python last.py bananas apples
bananas 1
C:\pjs\codegolf>python last.py bananas hazlenuts
hazlenuts 2
```
[Answer]
Bending the rules some...
## JavaScript (92)
```
p=prompt
~function f(a,b) {
a && !b && alert(0)
!a && b && alert(1)
f(a.slice(1), b.slice(1))
}(p(),p())
```
(Minified: `p=prompt;~function f(a,b){a&&!b&&alert(0);!a&&b&&alert(1);f(a.slice(1),b.slice(1))}(p(),p())`)
Takes two strings via `prompt`s. Alerts the difference in unary (as with Hasturkun's solution), using `0`s if the first string is longer and `1`s if the second string is longer. Outputs each digit in a separate alert (ow), and terminates eventually when the call stack runs out (owww).
If we ignore the rule about no addition or subtraction, we could easily have the number be a nice (base 10) number whose sign denotes which string is longer:
```
p=prompt
alert(function f(a,b,n) {
return a || b? f(a.slice(1), b.slice(1), n - !a + !b)
: n
}(p(),p(),0))
```
This version doesn't even wait for the call-stack to overflow!
[Answer]
**Perl, 69 characters**
```
sub l{l(map{substr$_,1}@_)if$_[0]&&$_[1];say pop()?2:1;die}l(<>,<>)
```
The gist is, recurse until one string is empty, then print the other. Run with `perl -e CODE 2> /dev/null`
[Answer]
# Python 3: 125 91 90
Finally beat the JavaScript solutions :)
Prints both which is longer, and by how much.
**Current (90 and Python 3):**
```
I=input
q=a,b=I(),I()
while a+b:s=q[b!=""];a=a[1:];b=b[1:];i=a and b and-1or-~i
print(s,i)
```
Example output:
```
rees@Rees-Ubuntu:~/Python/CodeGolf$ python3 StringComparer.py
hi <- input one
hello <- input two
hello 3 <- output
```
**Old (125 and Python 2):**
```
r=raw_input
q=a,b=r(),r()
while a and b:a=a[1:];b=b[1:]
s=(q[0],q[1])[a==""]
i=0
while a or b:a=a[1:];b=b[1:];i=-~i
print s,i
```
[Answer]
## Python, ~~708~~, ~~570~~, ~~566~~, ~~462~~, ~~492~~, ~~481~~, ~~480~~, ~~475~~, ~~363~~, ~~357~~, ~~354~~, ~~346~~, ~~343~~, ~~341~~, ~~340~~, ~~327~~, 315 (with whitespace)
My first CG, be gentle:
```
import sys
c=[1,2]
a=o=[]
l=d=e=v=0
s=sys.argv
r=range(0,99)
a=[zip(list(s[x]),r[1:]) for x in c]
a.insert(0,0)
for x in c:
for p in a[x]:
try:
v=a[x==2 and 1 or 2][p[1]]
except:
l=s[x]
o.append(1)
e=1
if e:break
o=zip(o,r)
print[l,o.pop()[1]]
```
**Sample run:**
```
me@home:~$ python diff.py bananas apples
['bananas', 1]
me@home:~$ python diff.py bananas hazlenuts
['hazlenuts', 2]
```
[Answer]
**C, 230 200 193 characters**
**EDIT: Shortened it from 230 to 193 characters.**
My first golf attempt. Maybe not a hole-in-one, but it works. Not being allowed to use strlen for this forces it to be fairly verbose in C. Maybe it can be shortened a bit?
```
a,b,w,i,l;
int main(int c,char **v){
for(;a<256||b<256;i++){
if(!v[1][i])a|=256;
if(!v[2][i])b|=256;
if(!(a&256))a++;
if(!(b&256))b++;
}
a&=255;b&=255;
w=a>b?0:1;
l=w?b-a:a-b;
printf("%s %i\n",v[w+1],l);
}
```
Or the uglier version:
```
a,b,w,i,l;int main(int c,char **v){for(;a<256||b<256;i++){if(!v[1][i])a|=256;if(!v[2][i])b|=256;if(!(a&256))a++;if(!(b&256))b++;}a&=255;b&=255;w=a>b?0:1;l=w?b-a:a-b;printf("%s %i\n",v[w+1],l);}
```
Example output:
```
N:\>golf.exe everything works
everything 5
```
[Answer]
**Powershell 140**
*(assumes a max difference of 999)*
```
$c=@(compare($args[0]-split'.')($args[1]-split'.'))
$n=[collections.stack]@(999..1)
$c|%{$n.pop()}
if($c){$args[$c[0].sideindicator-eq'=>']}
```
Outputs nothing if the string lengths are equal. If the string lengths are not equal, the longer string is displayed; the last number is the difference.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 89 bytes
```
i;c;q;j;f(a,b)char*a,*b;{for(i=j=c=0;a[i]||b[j];a[i]&&++i,b[j]&&++j)a[i]&&b[j]?:++c;a=c;}
```
[Try it online!](https://tio.run/##RY7BbsIwEETvfMXWFSghrtQzVsSllbiD1APhsHbWsFFiQ5yqB@DbUztURbLk2Tc7ozVvR2PGkZVRF9Uom6HUuTlhv0S51OpqfZ9x2ZSmfFe458PtpvfNYZKLRVGwTGNSTf5gaV6visIoLI26j681WXYEu8/tbiqHc89usJn4YGupJ2cINA0/RA4qMQ@VAHT1n1zBnCsnJKAELSGdBzrP1SxWQIfsshyus6lbDCcOEN/lmweC1rtjzInQ@VbEwGPHO59gQxBPChi3zxiedsCOplD6/2kiGGz9JBtqWy/hy/dt/ZLsZN3HXw "C (gcc) – Try It Online") I think this has room for improvement, but I'm not sure where. Abuses undefined behaviour, but it it Works On TIO™. Simply starts increment `c` when one of `a[i]` or `b[j]` is the null byte (the end of the string); `i` and `j` are incremented until they hit this null byte.
[Answer]
**Clojure - 206**
```
(defn is-longer [first second first-left second-left]
(defn remaining [current count]
(if (empty? current)
(/ (Math/log count) (Math/log 2))
(remaining (rest current) (bit-shift-left count 1))))
(cond
(empty? first-left) [2 (remaining second-left 1)]
(empty? second-left) [1 (remaining first-left 1)]
:else (is-longer first second (rest first-left) (rest second-left))))
```
Or minified:
```
(defn y [a b al bl] (defn x [u t] (if (empty? u) (/ (Math/log t) (Math/log 2)) (x (rest u) (bit-shift-left t 1)))) (cond (empty? al) [2 (x bl 1)] (empty? bl) [1 (x al 1)] :else (y a b (rest al) (rest bl))))
```
Or in prettierific:
Returns:
[1|2 count]
Getting around not using + was a fun challenge.
[Answer]
**Python, 194**
```
import sys,itertools as T
A=sys.argv
B=[]
N,i=None,0
for k,g in T.groupby(map(lambda f,b:[[0,1][b is N],2][f is N],A[1],A[2])):B.append(list(g))
for i,j in enumerate(B[1],1):0
print A[B[1][0]],i
```
[Answer]
## R - 120/114
Shows difference:
```
a=strsplit(scan(what='c'),"")
c=0
for(i in 1:2){for(y in a[[i]]){if(i-1)c=c+1 else c=c-1}}
d=abs(c)
cat(a[[(c==d)+1]],d)
```
Shows just the longer:
```
a=strsplit(scan(what='c'),"")
c=0
for(i in 1:2){for(y in a[[i]]){if(i-1)c=c+1 else c=c-1}}
cat(a[[(c==abs(c))+1]])
```
] |
[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 7 years ago.
[Improve this question](/posts/49332/edit)
Very simple, write a program that at first glance appears to be a quine, but is not. Upon running, the program actually prints the source to a real quine, obviously distinct from the original program in some way, preferably creative, but since this is a popularity contest, the answer with the most upvotes wins.
[Standard Loopholes which are no longer funny](http://meta.codegolf.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) are forbidden.
[Answer]
# CJam
```
{"_~"}_~
```
Well, whether this *looks* like a real quine to you depends on whether you're used to CJam or GolfScript, but anyway, it looks like and prints the standard quine:
```
{"_~"}_~
```
Wait, isn't that the same thing?
>
> Nope, there's a space at the end of the first code. I believe the same thing would work in almost any language with almost any quine.
>
>
>
[Test it here.](http://cjam.aditsu.net/#code=%7B%22_~%22%7D_~%20)
[Answer]
# [H9+](http://esolangs.org/wiki/H9+)
```
"Hello, world!"
```
It's easy: In H9+, anything other than H, 9, or + is ignored, and therefore, this is a quine. Or is it?
>
> Nope. H actually outputs `Hello, world!`, with no quotes.
>
>
>
[Answer]
# Python
```
s="s=%r\nprint(s%%s)"
print(s%s)
```
Explanation:
>
> The output actually has single quotes instead of double quotes.
>
>
>
[**Try it here**](http://repl.it/nqE)
[Answer]
# Mathematica
This one can be quite tricky to newer users.
```
Function[Print[StringJoin[ToString[FullForm[#0]], "[];"]]][];
```
Explanation:
>
> Some people might not notice the `#0` as not being part of the `FullForm`. In the output, it is replaced with `Slot[0]`. Everything else is the same.
>
>
>
[Answer]
# Haskell
Recursion can be tricky at times.
```
let s = "let s = " ++ show s ++ " in putStrLn s" in putStrLn s
```
---
>
> This actually outputs the same as '`s = "let s = " ++ show s in putStrLn s`', namely '`let s = "let s = \"let s = \\\"let s = \\\\\\\"let s = \\\\\\\\\\\\\\\"let s = \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\"...`'
>
>
>
---
>
> Basically, Haskell is trying to let `s` be equal to itself, with `let s =` appended to it, and escaping the string.
>
>
>
---
>
> Obviously, in order to escape `"` you need `\"`, and in order to escape `\` you get `\\`, which is how the long stream of backslashes is formed.
>
>
>
] |
[Question]
[
# Guidelines
### Task
Write a function that takes in a sentence (a string, or list of characters) and reverses all the words that are greater than or equal to 5 in length.
---
### Examples
`"Hey fellow code golfers" -> "Hey wollef code sreflog"`
`"I aM noT a cAr" -> "I aM noT a cAr"`
`"I Am a tRaiN" -> "I Am a NiaRt"`
---
### Rules
* Since this is code golf, the person with the least amount of bytes as their answer wins.
* The input will have only one space between two adjacent words and there will be no trailing or leading spaces.
* The output must also only have one space between two adjacent words and no trailing or leading spaces.
* You can assume that the input will either be a string, or an array of characters. It WILL NOT be an array of words.
* You must output either a string, or an array of characters. You MUST NOT output an array of words.
* Words with punctuation marks can be seen as 5 or 4 letters, whichever you want
* Capitalisation should stay the same for the same letters
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~12 10 8~~ 7 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
-1 thanks to [dylnan](https://codegolf.stackexchange.com/users/75553/dylnan) (use of repeat, `¡`, as a replacement of if, `?`, saving the need for identity, `¹`.)
```
ḲṚṫ¡€5K
```
A monadic link taking and returning lists of characters.
**[Try it online!](https://tio.run/##y0rNyan8///hjk0Pd856uHP1oYWPmtaYev///1/JPy9VoaQ8X6Ekoyg1VSEtv7RIIS2zLFXBUyElXyEnH8gqycgsViguyMzLy8xLV8gCSioBAA "Jelly – Try It Online")**
### How?
```
ḲṚṫ¡€5K - Link: list of characters
Ḳ - split at spaces (gets words)
5 - literal five
€ - for €ach word:
¡ - repeat:
ṫ - ...number of times: tail (5th character on, if empty falsey->0, else truthy->1)
Ṛ - ...action: reverse
K - join with spaces
```
---
Previous 8: `ḲṚ¹ṫ?€5K`
Previous 10: `ḲµṚ¹ṫ?5µ€K`
Previous 12s: `ḲµUµL€>4Tµ¦K` and `ḲµṚ¹L>¥?4µ€K`
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), ~~10~~ 8 bytes
*2 bytes saved thanks to @ETHproductions*
```
V`\w{5,}
```
[Try it online!](https://tio.run/##K0otycxLNPz/PywhprzaVKf2/3@P1EqFtNScnPxyheT8lFSF9PyctNSiYgA "Retina – Try It Online")
```
\w{5,} match 5 or more characters long strings
V` reverse each match and insert in place
```
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 123 bytes
```
,[[>++++[-<-------->]<[[-<+>]++++[-<++++++++>]>,>]<]<[>]<<<<<[[>]<[.<]>[>]]>>>>[[<]>[.>]]>>>>>,[>++++[->++++++++<]>.[-]]<<]
```
[Try it online!](https://tio.run/##NYxLCgIxEESvkn0@Jwi19g5FL3RMBjEYGBHx9LECmbdoqnh03Y7r41U/23OMQMILxhwXsExVD1vCL2AIktK6E87AlA0KBkHOklZDOMdxbkgnRtO/jXEpP1dLa/3rtn4vbu@tluP9Bw "brainfuck – Try It Online")
Most of this is just creating the ASCII value for space (32) 3 times, which is 51 bytes, or 41.4% of the total bytecount.
An attempt to only create one cell with 32 at the beginning and use that (124 bytes):
```
++++[->++++++++<],[[>[-<-<+>>>+<]<[[-<+>]>,>>>>]<[[-]>>>>]<<<]>>[-<+>]<<<<<<<<[[>]<[.<]>[[-]>]<<]>>>>[[<]>[.[-]>]]>,[>.>]<<]
```
[Answer]
# JavaScript (ES6), 60 bytes
*-57 bytes, w/ help from @Amorris, @Oliver, @Shaggy*
```
s=>s.split` `.map(w=>w[4]?[...w].reverse().join``:w).join` `
```
My first ever codegolf submission!
[Answer]
# [QuadR](https://github.com/abrudz/QuadRS), 10 bytes
```
\w{5,}
⌽⍵M
```
[Try it online!](https://tio.run/##KyxNTCn6/z@mvNpUp5brUc/eR71bff//90itVEhLzcnJL1dIzk9JVUjPz0lLLSoGAA "QuadR – Try It Online")
```
\w{5,} match 5 or more characters long strings
and replace
⍵M each match
⌽ with its reverse
```
[Answer]
## Haskell, ~~50~~ 49 bytes
```
f s|s>take 4s=reverse s|1<2=s
unwords.map f.words
```
[Try it online!](https://tio.run/##HYzBCsIwEAXvfsWjeLWgeDSe/QgvS7obS9MkZKtF6Ld3Dd6GgZkX6cQxWnBPe6c110H7mQqk//NBoJveF5oYV3WVP1yVmzvfLk5tpjHBodQxLTgioHvwF9KGeYXPAyPkKC3pYLuXSEHt5Ev5AQ "Haskell – Try It Online")
Edit: -1 byte thanks to @totallyhuman.
[Answer]
# [Python 2](https://docs.python.org/2/), ~~56~~ ~~51~~ 49 bytes
-3 bytes thanks to [Jonathan Allan](https://codegolf.stackexchange.com/users/53748/jonathan-allan)
-2 bytes thanks to [Mr. Xcoder](https://codegolf.stackexchange.com/users/59487/mr-xcoder)
-2 bytes thanks to [ElPedro](https://codegolf.stackexchange.com/users/56555/elpedro)
```
for w in input().split():print w[::len(w)<5or-1],
```
[Try it online!](https://tio.run/##K6gsycjPM/r/Py2/SKFcITMPiApKSzQ09YoLcjKBtFVBUWZeiUJ5tJVVTmqeRrmmjWl@ka5hrM7//0oeqZUKaak5OfnlCsn5KakK6fk5aalFxUoA "Python 2 – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 12 bytes
```
ð¡εDg4›iR]ðý
```
[Try it online!](https://tio.run/##ATQAy/8wNWFiMWX//8OwwqHOtURnNOKAumlSXcOww73//0hleSBmZWxsb3cgY29kZSBnb2xmZXJz "05AB1E – Try It Online")
**Explanation**
```
ð¡ # split on spaces
ε ] # apply to each word
D # duplicate
g # length
4› # greater than 4
iR # if true, reverse
ðý # join by space
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 11 bytes
*Saved a byte thanks to @Shaggy*
```
®Ê<5?Z:Zw}S
```
[Try it online!](https://tio.run/##y0osKPn//9C6w102pvZRVlHltcH//yt5pFYqpKXm5OSXKyTnp6QqpOfnpKUWFSsBAA "Japt – Try It Online")
### Explanation
```
® }S Split on spaces and map each word Z through this function:
Ê<5 If the length of Z is less than 5,
?Z return Z unchanged.
:Zw Otherwise, return Z reversed.
The words are then re-joined on spaces and sent to output.
```
---
## [Japt](https://github.com/ETHproductions/japt) v2, 11 bytes
```
r/\w{5,}/_w
```
[Test it online!](https://ethproductions.github.io/japt/?v=2.0a0&code=ci9cd3s1LH0vX3c=&input=IkhleSBmZWxsb3cgY29kZSBnb2xmZXJzIg==)
Thought of this just before the Retina answer was posted. Replaces each match of `/\w{5,}/g` with the match reversed.
[Answer]
# Perl, 22 bytes
Includes `+1` for `p`
```
perl -pe 's/\w{5,}/reverse$&/eg' <<< "Hey fellow code golfers"
```
[Answer]
## [><>](https://esolangs.org/wiki/Fish), ~~63~~ ~~53~~ 43 bytes
```
i>::48*=$0(+?v
6ov!?lr?(5l~ <.1
*^>i:0(?;48
```
[Try it online!](https://tio.run/##S8sszvj/P9POysrEQstWxUBD276Myyy/TNE@p8hewzSnTsFGz5BLK84u08pAw97axOL/f4/USoW01Jyc/HKF5PyUVIX0/Jy01KJiPQVPhURfhbz8EIVEhWTHIh0g3zEXyC4JSsz0AwA)
~~10~~ 20 bytes saved thanks to [Jo King](https://codegolf.stackexchange.com/users/76162/jo-king)!
[Answer]
# Python, ~~74~~ 69 Bytes
```
def f(a):print' '.join([i if len(i)<5else i[::-1]for i in a.split()])
```
Edit: -5 thanks to @ElPedro
[Answer]
# C, ~~105~~ 104 bytes
*Thanks to @ceilingcat for saving a byte!*
```
i,k;f(char*s){for(i=0;s[k=i]>32;)++i;for(;i>4&&k--;)putchar(s[k]);~k&&write(1,s,i+=k=!!s[i]);k&&f(s+i);}
```
[Try it online!](https://tio.run/##bY09C8IwFEX3/opnh5LYFvzaHi1000EHcZMOISb6SG0kqRQp@tdrOrh5p8c953FlfpVyHCkzqJm8CTf3fNDWMSoW6M@moLpcr5CnKeFUI5WbJDF5jvzx7KYHFqya48ckSe@oU2yZ@YzSwhSzmT9TQIFo5lPi@B6p7eAuqGU8GiII0Szeqhdo1TS2B2kvCq620cr5mGOY8CwOx0/dgdhDa08gQFbuv1HdA@2Ogg5T/R6/)
**Unrolled:**
```
i, k;
f(char*s)
{
for (i=0; s[k=i]>32;)
++i;
for (; i>4&&k--;)
putchar(s[k]);
~k && write(1, s, i+=k=!!s[i]);
k && f(s+i);
}
```
[Answer]
# [GolfScript](http://www.golfscript.com/golfscript/), 24 bytes
```
" "/{.,4>{-1%}{}if}%" "*
```
[Try it online!](https://tio.run/##S8/PSStOLsosKPn/X0lBSb9aT8fErlrXULW2ujYzrVYVKKb1/79HaqVCWmpOTn65QnJ@SqpCOlBXalExAA "GolfScript – Try It Online")
[Answer]
# [SNOBOL4 (CSNOBOL4)](http://www.snobol4.org/csnobol4/), ~~132~~ 119 bytes
```
s =input
s s arb . x (' ' | rpos(0)) rem . s
x =gt(size(x),5) reverse(x)
o =o x differ(s) ' ' :s(s)
output =o x
end
```
[Try it online!](https://tio.run/##HY2xDsIwDET3fMVtTSSEGGBBys5vUOpUkUJcxSktiH8PDtv53vlOMo@czq1B4GNe1mpE5b2MOGKHHTDgi7Kw2JNzKPRUX4wiP1cr8UN2d4dLJy8q0i8DhmdNTDEEKlYcestVVClbq478A4by1NqN3giUEm948ESYOemX/AA "SNOBOL4 (CSNOBOL4) – Try It Online")
[Answer]
# JavaScript, ~~69~~ 66 bytes
```
s=>s.split` `.map(i=>i.length>4?[...i].reverse().join``:i).join` `
```
[Try it online!](https://tio.run/##LcYxDoAgDADArzDiYCcnE/AhxqREGy1BIJTw/bp408UwgpyNa59zuUhVnBeQmrijQXhDtew8Q6J898cv2w4AfECjQU3IThALZ8SV/xlU/QA "JavaScript (Node.js) – Try It Online")
[Answer]
# [Red](http://www.red-lang.org), 98 bytes
```
f: func[a][parse a[any[copy n[to{ }| to end](if(length? n)> 4[n: reverse n]prin n)skip(prin{ })]]]
```
[Try it online!](https://tio.run/##Fc2xDgIhEIThV5lcdddbXaGtte2GgsByEsku4VBD1GdHrpv8yZcp7PuNPcj0sCI8xZE1lG3ZGZasNHKaG4SqfvD7oipYvJljmBPLVu8XyHLGiWRF4RcfTkwuUUbfHzHPxx50MWZcYLpyQ@CU9A2nnrFpCkNN/Q8 "Red – Try It Online")
## Ungolfed
```
f: func [a] [
parse a [ ; parse the argument on
any [ ; zero or more
copy n [ ; copy the matched substring to n
to { } ; scan to a space
| to end ; or to the end
]
( if (length? n) > 4 [ ; if the length of the match is bigger than 4
n: reverse n ; reverse the match
]
prin n) ; print the match
skip (prin { }) ; skip the space
]
]
```
[Answer]
# JavaScript, 53 bytes
An alternative, but slightly longer, method to the straightforward reversing of words of length ≥5, which Oliver beat me to.
```
s=>s.replace(/\S+/g,m=>[...m].sort(_=>!!m[4]).join``)
```
[Try it online](https://tio.run/##DcyxDsIgEADQX6GdIOp1cYXZ3bE2LcGDtDm4hms0/Xr0fcDb/MdLqOt@3Aq/sUXbxDqBijv5gHp4PS9DumbrRgDIEwjXQ8/WdV0e75OBjdeyLKYFLsKEQJx01P0DTxWRiL8q/F@VmCJW6Y1pPw)
[Answer]
# [Python 2](https://docs.python.org/2/), 53 bytes
```
for i in input().split():print i[::(-1,1)[len(i)<5]],
```
As far as I can see the , at the end does not leave a trailing space but please correct me if I am wrong.
[Try it online!](https://tio.run/##DcVRCoAgDADQqwy/FCoo6Ec6QHcQv2rWYDgxIzr9Ch688rZT8qSapAIB5V@5m3XDVZj@famUG1Dw3vZjN7rAmC25ZY6xUzUrvpCQWR7YZEc4hBPWy3w "Python 2 – Try It Online")
[Answer]
# Python 3, ~~67~~ 65 bytes
```
lambda s:' '.join([c[::-1]if len(c)>4 else c for c in s.split()])
```
[Answer]
## Pyth, 20 bytes
```
VcwdI>lN4p+_Nd.?p+Nd
```
[Try it online!](https://tio.run/##K6gsyfj/Pyy5PMXTLsfPpEA73i9Fz75A2y/l/3@P1EqFtNScnPxyheT8lFSF9PyctNSiYj0FT4VEX4W8/BCFRIVkxyIdIN8xF8guCUrM9AMA)
```
Vcwd | for N in input().split(" "):
I>lN4 | if len(N)>4:
p+_Nd | print(N[::-1]+" ", end="")
.? | else:
p+Nd | print(N+" ", end="")
```
[Answer]
# JavaScript, ~~73~~ 50 bytes
*-23 bytes thanks to Shaggy and ETHproductions*
```
s=>s.replace(/\w{5,}/g,x=>[...x].reverse().join``)
```
### Test cases
```
let f =
s=>s.replace(/\w{5,}/g,x=>[...x].reverse().join``)
console.log(f("Hey fellow code golfers"))
console.log(f("I aM noT a cAr"))
console.log(f("I Am a tRaiN"))
```
[Answer]
# Java 8, 131 bytes
```
s->s.join(" ",java.util.Arrays.stream(s.split(" ")).map(x->x.length()<5?x:new StringBuffer(x).reverse()+"").toArray(String[]::new))
```
**Explanation:**
[Try it online.](https://tio.run/##jY@xTsMwEED3fsUpky2IN5YWisoEQzMAG2I4nEtxcOzIvrSpUL49OGAxIiSfdD6/871r8Yil78m19cesLcYIezTucwVgHFNoUBNUyxXgiYNxB9AiJ1FuUn1KkU5kZKOhAgc3cyy3UbXeOFFAcdmmGWpgY9UuBDxHFTkQdiIlvTW8MFKqDnsxlttRWXIHfhfy@up2XDs65bl3Q9NQEKNUgY4UIgl5URRSsf/@NUu9vK6XHinnzY9XP7zZ5JX1jt7U0KUFf3GUeblzZOqUH1j16YWtE05pUdzTGRqy1p9A@5rg4G3SiMl482ffA@AenH8GBL0L/8B3XUL5EU2V4Wk1zV8)
```
s-> // Method with String as both parameter and return-type
s.join(" ", // Join String-array with spaces:
java.util.Arrays.stream( // An Array-stream of:
s.split(" ")) // The input-String split by spaces
.map(w-> // Mapped to:
w.length()<5? // If the word is not of length 5:
w // Leave the word as is
: // Else:
new StringBuffer(x).reverse()+"")
// Reverse it
.toArray(String[]::new)) // And convert the Stream to a String-array for the join
```
[Answer]
# [Perl 5](https://www.perl.org/) + `-p`, 21 bytes
```
s/\S{5,}/reverse$&/eg
```
[Try it online!](https://tio.run/##RckxCoAwEAXR3lNsIVZKqtzBXksb0a8GQjZkgyLi1V3thKnmRSRvVcUM3WXr2yTsSIKyMlhVW5y0wHs@aOIZtLJfPi76zQl9jZQhmaZR8L/AeUP65eGYHQfRJr4 "Perl 5 – Try It Online")
Replace (`s///`) all (`/g`) at least 5 (`{5,}`) non-whitespace (`\S`) by the evaluation (`/e`) of `reverse$&`/the reversed match.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~152~~ ~~125~~ 106 bytes
* Saved 19 bytes thanks to [ceilingcat](https://codegolf.stackexchange.com/users/52904/ceilingcat).
```
j;f(char*S){for(char*Z;*S;S=Z+!!*Z)for(Z=S+strcspn(S," "),j=0;Z-S>4&&--j*2>S-Z;Z[j]^=S[~j]^=Z[j]^=S[~j]);}
```
[Try it online!](https://tio.run/##fY9Na8MwDIbP269QDStx6sAYu3kJ5OOwXXqod3LWQcjsfJDGxTaUUbq/nsVtF7YdAkKy9D7Cr8qgKsthaKn0yrrQPsNHqfTlzanPKAv5arHwOXZjHrKVsbo0@95jBAHCpA3vKQ9Y9LhcBkHrP0Qs4JTn7fY9ZPmXK78aTE/Drmh6Dx9vb9wfEOfbED2LT5Ci69QBSvUhoFKdFNogeoUSB71AvIMC7KZo1pOSOuW1bgyMUfTK1kKDFcZORPaHmDTpxXi8OXEpdSnD43Svm95KDwHAnXnrn6JzQSQmZ48H1XVCXjwaLWSnKjS3lpAf1@um2NhZNiWTSy1qq/qr17mdjPy/bKRPwzc "C (gcc) – Try It Online")
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-S`](https://codegolf.meta.stackexchange.com/a/14339/), 9 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
¸®zZʨ5©2
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LVM&code=uK56WsqoNaky&input=IkhleSBmZWxsb3cgY29kZSBnb2xmZXJzIg)
[Answer]
# [CJam](https://sourceforge.net/p/cjam), 18 bytes
Port of my GolfScript answer.
```
lS/{_,4>{-1%}&}%S*
```
[Try it online!](https://tio.run/##S85KzP3/PydYvzpex8SuWtdQtVatVjVY6/9/j9RKhbTUnJz8coXk/JRUhfT8nLTUomIA "CJam – Try It Online")
[Answer]
# [Husk](https://github.com/barbuz/Husk), 10 bytes
```
wm?↔Io>5Lw
```
[Try it online!](https://tio.run/##yygtzv7/vzzX/lHbFM98O1Of8v///3ukViqkpebk5JcrJOenpCqk5@ekpRYVAwA "Husk – Try It Online")
] |
[Question]
[
Your program must print out this exact sequence:
```
1
2
4
10
24
54
116
242
496
1006
2028
4074
8168
16358
32740
65506
131040
262110
NOPE!
```
As usual, shortest program wins. Standard code golf rules apply.
[Answer]
# [Python 2](https://docs.python.org/2/), 51 bytes
```
i=0;exec"print 2**i-i<<(i>0);i+=1;"*18;print"NOPE!"
```
[Try it online!](https://tio.run/##K6gsycjPM/r/P9PWwDq1IjVZqaAoM69EwUhLK1M308ZGI9POQNM6U9vW0FpJy9DCGiyr5Ocf4Kqo9P8/AA "Python 2 – Try It Online")
Notices that the formula is **2(2n-n)**, for all **n** except **0**.
Saved two bytes thanks to [Wheat Wizard](https://codegolf.stackexchange.com/users/56656/wheat-wizard) (`i<<1-(i<1)` changed to `i<<(i>0)`, duh!).
---
### [Python 2](https://docs.python.org/2/), 53 bytes
```
i=0;exec"print[2**i-i<<(i>0),'NOPE!'][i>17];i+=1;"*19
```
[Try it online!](https://tio.run/##K6gsycjPM/r/P9PWwDq1IjVZqaAoM68k2khLK1M308ZGI9POQFNH3c8/wFVRPTY6087QPNY6U9vW0FpJy9Dy/38A "Python 2 – Try It Online")
[Answer]
# Fortran 95, ~~82~~ 74 bytes
Compiled with `gfortran`, with the `-cpp` flag to enable preprocessing, or saving the file with `.F95` extension.
```
#define p print*,
program w
p 1
do i=1,17
p 2*(2**i-i)
enddo
p'NOPE!'
end
```
~~Longest answer!~~ Not anymore! YAY!
[Answer]
# [Emojicode](http://www.emojicode.org/), 96 bytes
```
üèÅüçáüòÄüî°1 2üîÇi‚è©1 18üçáüòÄüî°‚úñ2‚ûñüèáüèÇ2.0üöÄi i 10üçâüòÄüî§NOPE!üî§üçâ
```
[Try it online!](https://tio.run/##S83Nz8pMzk9J/f//w/z@xg/ze9s/zJ/R8GH@lIWGCkZAqinzUf9KQwVDC2SpR3OmGT2aNw2oAyjU32SkZ/Bh/qyGTIVMBUMgq7cTqm6Jn3@AqyKIARL8/x8A "Emojicode – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 20 bytes
```
17Rµ2*_×2“NOPE!”ṭ1;Y
```
[Try it online!](https://tio.run/##ASUA2v9qZWxsef//MTdSwrUyKl/DlzLigJxOT1BFIeKAneG5rTE7Wf// "Jelly – Try It Online")
**Explanation**
```
17Rµ2*_×2“NOPE!”ṭ1;Y
17R range(17):[1,2,...17]
µ new monadic link
2* exponentiate: [2*1, 2*2,...2*17]
_ subtract: [2*1-1, 2*2-1,...2*17-17]
×2 times 2. Ḥ would need an additional syntax character but ×2 doesn't.
“NOPE!”ṭ append "NOPE!" to the above list
1; prepend 1 to the above list
Y join by newlines and implicitly print
```
**A recursive [Jelly](https://github.com/DennisMitchell/jelly) solution, 26 bytes**
```
’ß+_3$ḤµṖṖ$¡
18RÇ€Y⁷“NOPE!
```
Took the `Y⁷“NOPE!` trick from Jonathan Allan.
[Try it online!](https://tio.run/##y0rNyan8//9Rw8zD87XjjVUe7lhyaOvDndOASOXQQi5Di6DD7Y@a1kQ@atz@qGGOn3@Aq@L///8B "Jelly – Try It Online")
[Answer]
# [SOGL V0.12](https://github.com/dzaima/SOGLOnline), 16 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md)
```
1O'²∫ūF-«O"NOPE!
```
[Try it Here!](https://dzaima.github.io/SOGLOnline/?code=MU8lMjclQjIldTIyMkIldTAxNkJGLSVBQk8lMjJOT1BFJTIx,v=0.12)
Explanation:
```
1O output 1
'²∫ 17 times do, pushing 1-indexed counter
≈´ calculate 2^pop
F- subtract from that the counter
¬´ multiply by 2
O output
"NOPE! push "NOPE!", which gets printed at the end as implicit output hasn't been disabled. This gets pushed every iteration of the loop, to save a byte
```
[Answer]
# [Matlab](https://www.mathworks.com/products/matlab.html) (R2016b), ~~71~~ 69 bytes
Saved 2 bytes thanks to @Giuseppe (replace `2*(i-2)` by `2*i-4`)
This version prints exactly as required:
```
a=1;for i=1:18,fprintf('%d\n',a),a=2*a+max(2*i-4,0);end,disp('NOPE!')
```
# [Matlab](https://www.mathworks.com/products/matlab.html) (R2016b), ~~53~~ 51 bytes
This version prints the same numbers and the `NOPE!`, but with a different formatting:
```
a=1,for i=1:17,a=2*a+max(2*i-4,0),end,disp('NOPE!')
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~18~~ 17 bytes
```
X17LDoα·»"NOPE!"»
```
[Try it online!](https://tio.run/##MzBNTDJM/f8/wtDcxyX/3MZD2w/tVvLzD3BVVDq0@/9/AA "05AB1E – Try It Online")
**Explanation**
```
X # push 1
17L # push range [1 ... 17]
D # duplicate
o # raise 2 to the power of each
α # absolute difference
· # times 2
» # join list on newlines
"NOPE!" # push this string
» # join stack on newlines
```
[Answer]
# [MATL](https://github.com/lmendo/MATL), 19 bytes
```
l17:tWw-E"@]'NOPE!'
```
[Try it online!](https://tio.run/##y00syfn/P8fQ3KokvFzXVckhVt3PP8BVUf3/fwA "MATL – Try It Online")
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 23 bytes
```
18Çn2pZ¹*2Ãh1 ·+"
NOPE!
```
[Try it online!](https://tio.run/##y0osKPn/39DicHueUUHUoZ1aRoebMwwVDm3XVuLy8w9wVfz/HwA)
---
# 24 bytes
```
17õ!²i½ í- m*2 ·+"
NOPE!
```
[Try it online!](https://tio.run/##y0osKPn/39D88FbFQ5syD@1VOLxWVyFXy0jh0HZtJS4//wBXxf//AQ)
[Answer]
# Javascript (ES2016), ~~58~~ ~~55~~ 54 bytes
*Saved 1 byte thanks to @l4m2*
*Saved 1 byte thanks to @user71546*
```
for(i=0;i<18;l(2**i-i<<!!i++))l=console.log;l("NOPE!")
```
Uses the formula `2(2n-n)` for all `n ≠ 0` and `2n-n` for `n = 0`, based on @MrXcoders [Python 2 answer](https://codegolf.stackexchange.com/a/151907/70894)
## If returning an array of lines is allowed, ~~54~~ 52 bytes
```
_=>[...""+1e19].map((_,i)=>i>18?"NOPE!":2**i-i<<!!i)
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 19 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
1⁷17µ2*_µ€ḤY⁷“NOPE!
```
A full program printing the result to STDOUT.
**[Try it online!](https://tio.run/##y0rNyan8/9/wUeN2Q/NDW4204g9tfdS05uGOJZFAoUcNc/z8A1wV////DwA "Jelly – Try It Online")**
### How?
```
1⁷17µ2*_µ€ḤY⁷“NOPE! - Main link: no arguments
1 - literal 1 (printed as next byte starts a new leading constant chain)
⁷ - literal newline (also printed for the same reason)
17 - literal seventeen
µ µ€ - for €ach n in range -> [1,2,3,...,17]
2 - literal two
* - raise to power n -> [2,4,8,...,131072]
_ - subtract n -> [1,2,5,...,131055]
Ḥ - double (vectorises) -> [2,4,10,...,262110]
Y - join with newlines (again this is printed, as above)
⁷ - literal newline (this is also printed for the same reason)
“NOPE! - literal list of characters "NOPE!" (no trailing close quote required
- at the end of a Jelly program)
- implicit print
```
Some alternatives exist for 19 bytes, like
```
‘Ṅ+⁴2*$_$€ḤY⁷“NOPE!
```
[Answer]
## Batch, 89 bytes
```
@echo 1
@set/ap=2
@for /l %%i in (0,2,32)do @call echo %%p%%&set/ap+=p+%%i
@echo NOPE!
```
[Answer]
# Perl 5, 42 bytes
```
say for 1,(map 2*(2**$_-$_),1..17),"NOPE!"
```
[Try it online](https://tio.run/##K0gtyjH9/784sVIhLb9IwVBHIzexQMFIS8NIS0slXlclXlPHUE/P0FxTR8nPP8BVUen//3/5BSWZ@XnF/3V9TfUMDAE)
[Answer]
# [Bubblegum](https://esolangs.org/wiki/Bubblegum), 57 bytes
```
00000000: 04c1 4101 4331 0042 b1fb 5303 94f2 3bff ..A.C1.B..S...;.
00000010: c696 9850 2c52 6eb1 471a fa1b 9646 9447 ...P,Rn.G....F.G
00000020: f595 e73d bc73 1f27 5fc5 eed5 f0b1 2ab2 ...=.s.'_.....*.
00000030: d8e2 3f3f ff00 5745 00 ..??..WE.
```
[Try it online!](https://tio.run/##Zc@9SkRBDAXg3qc4nSByyPzd2VmRRUW3FS0s5WbuxEZtZJ//mtW1MkUICXyc6EH1fbwdPtZVTrWF5B6Qg3hLKUAkR2gwRUmS0LJFJDUDyBveBd6SzySvePYrBDf61Ca0TRHEXiKmoa7VMMPmoGhT9mvO9Wjw8fLpk3sf@MD9yYhuWGkFo6YF2mtCsFhRrPtuLAUmTsZZ449xzS@evx4NXvzlSG4sm@FpLRnMRFBqLv4Q/he525Ev91zXbw "Bubblegum – Try It Online")
[Answer]
# [R](https://www.r-project.org/), ~~56~~ ~~51~~ 39 bytes
```
cat(1,2*(2^(x=1:17)-x),"NOPE!",sep="
")
```
[Try it online!](https://tio.run/##K/r/PzmxRMNQx0hLwyhOo8LW0MrQXFO3QlNHyc8/wFVRSac4tcBWiUtJ8/9/AA "R – Try It Online")
[Answer]
# Java 10, ~~94~~ 80 bytes
```
a->{var r="";for(int i=0;i<18;)r+=(i<1?1:2)*((1<<i)-i++)+"\n";return r+"NOPE!";}
```
Using the formula from Herman Lauenstein's [answer](https://codegolf.stackexchange.com/a/151941/79343).
Thanks to Kevin Cruijssen for golfing 14 bytes.
Try it online [here](https://tio.run/##LY4xb8IwEIVn51dcPdm1EhEmVCft1IGhtBISC3S4hoCOBic6O5EqlN@eGoXtnk7vfd8FB0wvx9@p638aqqBq0Hv4QHJwSwS5UPMJqxrW9yi2gcmdoVO7lo7QapuIMRE@YIjVNRCUMGH6ehuQgUsp7allFUeAyoWlIl9ZzaZU8XrLX5b6Wam8KEinZIw28uCk5Tr07ICN3Hx@vT9JO04iUh52D9Jwp1@jo5qF9t@AfPZ6dvzzob5mbR@yLj6DoqxTrm8aPeuO0z8).
Ungolfed version:
```
a -> { // lambda taking an unused null parameter
var r = ""; // we build the output as a String
for(int i = 0; i < 18; ) // generate the sequence
r += (i < 1 ? 1 : 2) * ((1 << i) - i++) + "\n"; // append 2*(2^i-i) for n > 0, 2^i-i for n = 0
return r + "NOPE!"; // return the constructed sequence, with NOPE! appended
}
```
[Answer]
# [Python 2](https://docs.python.org/2/), 61 bytes
```
i=0
x=1
print 1
exec"x*=2;print x;x+=i;i+=1;"*17
print"NOPE!"
```
[**Try it online**](https://tio.run/##K6gsycjPM/r/P9PWgKvC1pCroCgzr0TBkCu1IjVZqULL1sgaIlJhXaFtm2mdqW1raK2kZWgOUajk5x/gqqj0/z8A)
[Just search OEIS](https://oeis.org/search?q=1%202%204%2010%2024%2054%20116%20242%20496%201006%202028%204074%208168%2016358%2032740%2065506%20131040%20262110&sort=&language=english&go=Search)
[Answer]
# [Haskell](https://www.haskell.org/), 50 bytes
```
(unlines$show<$>1:[2*(2^n-n)|n<-[1..17]])++"NOPE!"
```
[Try it online!](https://tio.run/##y0gszk7NyflfbBvzX6M0LyczL7VYpTgjv9xGxc7QKtpIS8MoLk83T7Mmz0Y32lBPz9A8NlZTW1vJzz/AVVHpf25iZp6CrUJBaUlwSZFC8f9/yWk5ienF/3WTCwoA "Haskell – Try It Online")
[Answer]
# PHP 5.6+, 65 bytes
```
<?=1,"\n";for($i=0;$i++<17;){echo 2*(2**$i-$i),"\n";}echo"NOPE!";
```
[Try it online!](https://tio.run/##K8go@P/fxt7WUEcpJk/JOi2/SEMl09bAWiVTW9vG0Nxaszo1OSNfwUhLw0hLSyVTVyVTE6KyFiSu5Ocf4KqoZP3/PwA)
[Answer]
# [Clean](https://clean.cs.ru.nl), ~~92~~ 65 bytes
```
import StdEnv
Start=("1\n",[(2*(2^n-n),'
')\\n<-[1..17]],"NOPE!")
```
Trivia: The type that is actually being printed is `(String, [(Int, Char)], String)`
[Try it online!](https://tio.run/##S85JTcz7n5ufUpqTqpCbmJn3PzO3IL@oRCG4JMU1r4wruCSxqMRWQ8kwJk9JJ1rDSEvDKC5PN09TR51LXTMmJs9GN9pQT8/QPDZWR8nPP8BVUUnz//9/yWk5ienF/3U9ff67VOYl5mYmAzlJAA "Clean – Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 18 bytes
```
Ｅ¹⁸Ｉ⎇ι⊗⁻Ｘ²ιι¹NOPE!
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMM3sUDD0EJHwTmxuEQjJLUoL7GoUiNTR8ElvzQpJzVFwzczr7RYIyC/PLVIw0hHIVMThIGEoSYQWHNBDFHy8w9wVVTStP7//79uWQ4A "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
¹⁸ Literal 18
Ｅ Map over implicit range
² Literal 2
ι Current value
Ｘ Exponentiate
ι Current value
⁻ Subtract
‚äó Double
¬π Literal 1
ι Current value
‚éá Ternary
Ｉ Cast to string
Implicitly print on separate lines
NOPE! Literal string
Implictly print
```
[Answer]
# [Haskell](https://www.haskell.org/), 47 bytes
```
unlines[show$2*(2^x-x)-0^x|x<-[0..17]]++"NOPE!"
```
[Try it online!](https://tio.run/##y0gszk7NyflfbBvzvzQvJzMvtTi6OCO/XMVIS8MorkK3QlPXIK6ipsJGN9pAT8/QPDZWW1vJzz/AVVHpf25iZp5tQWlJcEmRQvH/f8lpOYnpxf91kwsKAA "Haskell – Try It Online")
[Answer]
# Bash, 67 characters
```
echo 1
for((i=0;i++<17;));do
echo $((2*(2**i-i)))
done
echo "NOPE!"
```
[Try it online!](https://tio.run/##S0oszvj/PzU5I1/BkCstv0hDI9PWwDpTW9vG0NxaU9M6JZ8LLKmioWGkBURambqZmpqaXCn5eakQGSU//wBXRaX//wE)
[Answer]
# [Wolfram Language](http://reference.wolfram.com) , 82 bytes
```
DifferenceRoot[Function[{y,n},{4-2 n-2 y[n]+y[1+n]==0,y[1]==1,y[2]==2}]]/@Range@18
```
This is actually a holonomic sequence whose solution was obtained from
```
f = FindSequenceFunction[{1, 2, 4, 10, 24, 54, 116, 242, 496, 1006}]
```
>
>
> ```
> DifferenceRoot[Function[{y,n},{4 - 2 n - 2 y[n] + y[1 + n] == 0, y[1] == 1, y[2] == 2}]]
>
> ```
>
>
I don't know why the `NOPE!` is needed as the sequence does continue
```
f[19]
```
>
>
> ```
> 524252
>
> ```
>
>
[Answer]
# [SNOBOL4 (CSNOBOL4)](http://www.snobol4.org/csnobol4/), ~~97~~ 83 bytes
```
OUTPUT =1
I X =X + 1
OUTPUT =LT(X,18) 2 * (2 ^ X - X) :S(I)
OUTPUT ='NOPE!'
END
```
[Try it online!](https://tio.run/##K87LT8rPMfn/n9M/NCQgNETB1pDLkzNCwTZCQVvBkAsu6hOiEaFjaKGpYKSgpaBhpBCnEKGgqxChqcBpFazhqYlQqO7nH@CqqM7l6ufy/z8A "SNOBOL4 (CSNOBOL4) – Try It Online")
I'm still not really sure why I had two counters going; I only needed one.
[Answer]
# [AWK](https://www.gnu.org/software/gawk/manual/gawk.html), 48 bytes
```
END{for(;i++<17;){print 2*(2**i-i)}print"NOPE!"}
```
[Try it online!](https://tio.run/##SyzP/v/f1c@lOi2/SMM6U1vbxtDcWrO6oCgzr0TBSEvDSEsrUzdTsxYsoOTnH@CqqFT7/z8A "AWK – Try It Online")
[Answer]
# C, ~~ 71 ~~ ~~ 70 ~~ 68 bytes
*Thanks to @Mr. Xcoder for saving three bytes!*
```
f(n){for(n=-1;++n<18;)printf("%d\n",((1<<n)-n)<<!!n);puts("NOPE!");}
```
[Try it online!](https://tio.run/##S9ZNT07@/z9NI0@zOi2/SCPPVtfQWls7z8bQwlqzoCgzryRNQ0k1JSZPSUdDw9DGJk9TN0/TxkZRMU/TuqC0pFhDyc8/wFVRSdO69j9QsUJuYmaehiZXNZcCEKRpaFpz1f4HAA)
[Answer]
# [Recursiva](https://github.com/officialaimm/recursiva), 23 bytes
```
E++A1mB17"D~^2a"A"NOPE!
```
[Try it online!](https://tio.run/##K0pNLi0qzixL/P/fVVvb0TDXydBcyaUuzihRyVHJzz/AVfH/fwA "Recursiva – Try It Online")
```
E++A1mB17"D~^2a"A"NOPE! - Implicitly print the evaluated value
E - Join with newline
+ - Concatenate
+A1mB17"D~^2a" - [1, 2, 6, 14... 262142]
+ - Concatenate
A1 - Listify 1 [1]
mB17"D~^2a" - [2,6,14... 262142]
m - map with
B17 - [1,2...17]
"D~^2a" - Function 2(2^n - 1)
A"NOPE! - Listify ["NOPE!"]
```
[Answer]
# [Perl 6](https://perl6.org), 35 bytes
```
{1,{2*(2**++$-++$)}.../21/,'NOPE!'}
```
[Try it](https://tio.run/##K0gtyjH7X1qcqlBmppdszZVbqaCWnJ@SqmD7v9pQp9pIS8NIS0tbW0UXiDVr9fT09I0M9XXU/fwDXBXVa//rFSdWKqTlFymA9Gho/gcA "Perl 6 – Try It Online")
```
{ # bare block lambda
1, # start the sequence with `1`
{ # bare block used to generate values
2*(
2 ** ++$ # 2 to the power of an incrementing state variable
-
++$ # incrementing anonymous state variable
)
}
... # keep generating values until
/21/, # it generates a value that contains '21'
'NOPE!' # continue sequence with string 'NOPE!'
}
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), 43 bytes
```
->{[1]+(1..17).map{|i|2*(2**i-i)}<<"NOPE!"}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf16462jBWW8NQT8/QXFMvN7GguiazxkhLw0hLK1M3U7PWxkbJzz/AVVGp9n9BaUmxQlp07H8A "Ruby – Try It Online")
A lambda returning an array of integers (and one string). Breaking out 1 into a special case was pretty cheap, and didn't hurt my brain at all!
] |
[Question]
[
This challenge is very simple:
Given an angle measure in degrees or radians (your choice), output the angle between 0 and 2π non-inclusive [0º, 360º) that is [coterminal](http://www.softschools.com/math/trigonometry/coterminal_angles/) with it.
## Input
A positive or negative angle measure. You can pick if you want to take it in degrees or in radians.
## Output
The angle on [0, 2π) that is coterminal with the input angle. If you take the input in degrees, the output must also be in degrees; if you take it in radians, the output must be in radians too. The coterminal angle is essentially a the angle mod 360°.
## Examples (in degrees)
```
745 -> 25
1728 -> 288
90 -> 90
0 -> 0
360 -> 0
-50 -> 310
-543.21 -> 176.79
```
[Answer]
# [Python 3](https://docs.python.org/3/), 14 bytes
```
lambda n:n%360
```
[Try it online!](https://tio.run/nexus/python3#S7ON@Z@TmJuUkqiQZ5Wnamxm8D8tv0ghUyEzTyHa3MRUR8HQ3MhCR8HSQEcBiIDyOgq6pmDCxFjPyDDWiouzoCgzr0RDqbpWQddOobpWSQ9oQm5iiUamTppGpqam5n8A "Python 3 – TIO Nexus")
[Answer]
# R, 11 bytes
takes input from stdin in degrees
```
scan()%%360
```
[Try it online!](https://tio.run/nexus/r#@1@cnJinoamqamxm8N/cxFTB0NzIQsHSQMFAASiioGsKwibGekaG/wE)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 4 bytes
Just because there were no answers using radians.
```
žq·%
```
[Try it online!](https://tio.run/nexus/05ab1e#Dc3LCcJQEAXQ/atCAu7MMP87Y1duhIB9uTNgsK5nCjic13Obv8/j@77ObTn2@@XYl9sUI2YFayssgMhhTBKt1Q73VBYfQgFGp2mivTpzMPFI0jKpMIago3KsTAXNPF10Q9JrrE1eXGxngijr@gM "05AB1E – TIO Nexus")
[Answer]
# [MATL](https://github.com/lmendo/MATL), ~~5~~ 4 bytes
```
360\
```
[Try it online!](https://tio.run/nexus/matl#@29sZhDz/7@5iSkA "MATL – TIO Nexus")
My first attempt with MATL!
*-1 byte, just realised `i` is not necessary for recording the input...*
[Answer]
# [Python 3](https://docs.python.org/3/), 13 bytes
```
360..__rmod__
```
Explanation:
`num.__rmod__(x)` is equivalent to `x%num` (rmod is modulo from the right.).
[Answer]
# [CJam](https://sourceforge.net/p/cjam), 12 bytes
```
rd360:X%X+X%
```
All those extra bytes because CJam gives negative results for mods...
[Try it online!](https://tio.run/nexus/cjam#q/5flGJsZmAVoRqhHaH6P6/WXOu/uYkpl6G5kQWXpQGXARdQlkvXFIRNjPWMDAE "CJam – TIO Nexus")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 4 bytes
```
360%
```
[Try it online!](https://tio.run/nexus/05ab1e#K6v8b2xmoPpf53@0uYmpjqG5kYWOpYGOgQ5QVEfXFIRNjPWMDGMB "05AB1E – TIO Nexus")
```
360 # push 360
% # pop a,b: push (a % b)
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 4 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
%360
```
**[Try it online!](https://tio.run/nexus/jelly#@69qbGbw//9/cxNTAA "Jelly – TIO Nexus")**
I was kind of hoping `Æ°°` would do it for 3.
[Answer]
# Java 7, ~~44~~ 43 bytes
[Crossed out 44 is still regular 44 ;(](https://codegolf.stackexchange.com/a/111671/52210)
```
float c(float n){return(n%=360)<0?n+360:n;}
```
**Explanation:**
Java uses remainder instead of actual modulo for negative numbers ([source](https://stackoverflow.com/questions/4403542/how-does-java-do-modulus-calculations-with-negative-numbers)). So we'll have to manually fix the negative cases.
```
float c(float n){ // Method with float input and float return-type
return(n%=360)<0? // If input mod-360 is negative
n+360 // Return input mod-360 + 360
: // Else:
n; // Return input mod-360
} // End of method
```
**Test code:**
[Try it here.](https://tio.run/nexus/java-openjdk#jc/PCoJAEAbwu08xCMEukvg3K4ueoJPH6LBtGgs6yu4YhPjsptU19DQfzO8bGFkKY@DcWQCGBCkJQ1HWgkCy70Te6ZxajQxXx3Dj8YN3QmcMe0z7AaBpb@XY@pWftbpDJRSyjLTCx@UKgk/HAbKXobxy65bcZlwRkyyJYg4O2CnYPP2H/CTYzqudN28WkOnBWbSOF6EodAO/4B/SW/3wBg)
```
class M{
static float c(float n){return(n%=360)<0?n+360:n;}
public static void main(String[] a){
System.out.print(c(745) + "; ");
System.out.print(c(1728) + "; ");
System.out.print(c(90) + "; ");
System.out.print(c(0) + "; ");
System.out.print(c(360) + "; ");
System.out.print(c(-50) + "; ");
System.out.print(c(-543.21f));
}
}
```
**Output:**
```
25.0; 288.0; 90.0; 0.0; 0.0; 310.0; 176.78998
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~14 11 10~~ 4 bytes
```
u#Ũ
```
[Try it online!](https://tio.run/nexus/japt#@1@qfHTF//@6pgYA "Japt – TIO Nexus")
Takes input in degrees.
# Explanation
```
u#Ũ
Uu360
U # (implicit input)
u # modulo
360 # 360
# (implicit output)
```
[Answer]
# C, 69 43 bytes
This [*seems* like an excessively trivial challenge](https://codegolf.stackexchange.com/questions/118863/find-the-coterminal-angle-on-0-2%CF%80#comment291308_118863), and indeed in many languages it is. The trick is in the implementation details of the modulo operator.
When both modulo operands are positive, nothing interesting happens. But when one of the operands is negative, then the results start depending on your interpretation of what should happen. You can either always return a positive result, return a result whose sign depends on the dividend, or return a result whose sign depends on the divisor.
[Programming languages are quite divided on which behavior they choose to implement](https://en.wikipedia.org/wiki/Modulo_operation). The lucky ones for this challenge are the ones that always return a positive result, since that's what the test cases call for.
If you happen to be golfing in a language that implements modulo dependent on the sign of the dividend, then you have to do extra work to compensate for negative inputs—and to make sure that this compensation does not break positive inputs!
Here's a further golfed implementation in C (thanks to ais523):
```
f(double*n){*n=fmod(fmod(*n,360)+360,360);}
```
[Try it online!](https://tio.run/nexus/c-clang#XZDLbsMgEEX3/opRolYGP4SdZ0WSL4i666rpwrFNgoRxhHE3kX@9dIwXTTqLmcvMuQxiLnWp@qqGXWcr2abXQzB/bCl5xp4TYdX2Z1VTTe5U70XTVqFPVMeLNSMRJi/44KS20BRSh6MozKWMobwWBijFwzcJ7gFgiNaAJyTsIeNYdh7mEEWSeGQCx5iWg9S33gLynTUWl4/3fcqvGN4/jkfC/@Om7nplEfe@v7EIX6fRg@Vm8C0inL2kuTjZ5HCyXulZPLljeLIMPpva9kYD48HgXLJaLtI8w8oc/oRj7o25bJNv3Wa5@imFKi6dS1TzCw)
Notice that C is also hobbled here by the unfortunate omission of a modulo operator (*a la* `%`) for floating-point operations. Instead, you have to call a library function.
[Answer]
# JavaScript (ES6), ~~21~~ ~~19~~ 18 bytes
Takes input in degrees.
```
n=>(n%360+360)%360
```
* Saved 2 bytes thanks to [Luke](https://codegolf.stackexchange.com/users/63774/luke).
* Saved 1 byte thanks to [Neil](https://codegolf.stackexchange.com/users/17602/neil).
---
## Try it
```
f=
n=>(n%360+360)%360
i.addEventListener("input",_=>o.innerText=f(+i.value))
console.log(f(745)) // 25
console.log(f(1728)) // 288
console.log(f(90)) // 90
console.log(f(0)) // 0
console.log(f(360)) // 0
console.log(f(-50)) // 310
console.log(f(-543.21)) // 176.79
```
```
<input id=i type=number><pre id=o>
```
[Answer]
# Mathematica, 10 bytes
```
#~Mod~360&
```
Pure function taking any type of numerical input in degrees. Does what it says on the tin.
[Answer]
# [Fourier](https://github.com/beta-decay/Fourier), ~~22~~ ~~14~~ 6 bytes
```
I%360o
```
[Try it online!](https://tio.run/nexus/fourier#@@@pamxmkP//v66pAQA "Fourier – TIO Nexus")
Simply outputs the input modulo 360.
Note that since the interpreter for TIO is written in Python, this will not work on <http://beta-decay.github.io/editor>
[Answer]
# x86 Assembly (targeting the x87 FPU), 23 bytes
As is standard with 32-bit calling conventions, the double-precision floating-point parameter is passed on the stack, and returned at the top of the x87 FPU stack. Assemble with MASM:
```
.MODEL flat
.686 ; fucomip requires a Pentium Pro or later CPU
CONST SEGMENT
divisor DD 043b40000r ; 360.0f
CONST ENDS
PUBLIC _CoterminalAngle
_TEXT SEGMENT
_CoterminalAngle PROC
fld DWORD PTR [divisor] ; single-precision takes fewer bytes to store; we don't need the precision
fld QWORD PTR [esp + 4] ; load parameter from stack
fprem ; st(0) = parameter % 360
; st(1) = 360
fldz
fucomip st(0), st(1) ; st(0) < 0?
jbe Finished
fadd st(0), st(1) ; fixup negative modulo by adding 360
Finished:
fstp st(1) ; discard st(1); result is left in st(0)
ret
_CoterminalAngle ENDP
_TEXT ENDS
END
```
To call from C:
```
extern double CoterminalAngle(double value);
```
In bytes:
```
43B40000
D9 05 00 00 00 00
DD 44 24 04
D9 F8
D9 EE
DF E9
76 02
D8 C1
DD D9
C3
```
**Notes:**
As the comment indicates, to minimize code size, I've stored the divisor constant (`360.0f`) as a single-precision floating-point value. This means it is half the length it would be if it were a double-precision value, and we don't need the precision to store a proper representation of the value. Upon loading, the x87 FPU will implicitly extend it to its native ten-byte extended-precision format.
We're also playing it fast-and-lose with the [`FPREM` instruction](http://x86.renejeschke.de/html/file_module_x86_id_107.html) for golfing purposes, assuming it does not need to reduce the exponent of the input value by more than 63. The *careful* (read: correct) way to call it would be iteratively, in a loop, continuing to execute it as long as the "parity" flag is set.
For example:
```
RemainderLoop:
fprem
fstsw ax
sahf
jp RemainderLoop
```
That would add 6 bytes to the total.
---
# x86 Assembly (targeting AVX), 47 bytes
By way of comparison (and for completeness), here's an AVX implementation. It's more bytes, but also more efficient. The parameter is passed in `XMM0`, and the result is returned in the same register, as with any x86-64 or vector x86-32 calling convention.
```
43 B4 00 00 | divisor DD 043b40000r ; 360.0f
```
```
| ; Load single-precision FP value, and convert it to double-precision.
C5 EA 5A 15 00 | vcvtss2sd xmm2, xmm2, DWORD PTR [divisor]
00 00 00 |
| ; Divide input parameter (XMM0) by divisor (XMM2), and store result in XMM1.
C5 FB 5E CA | vdivsd xmm1, xmm0, xmm2
|
| ; Truncate the result of the division to the nearest integer.
C5 FB 2C C1 | vcvttsd2si eax, xmm1
C5 F3 2A C8 | vcvtsi2sd xmm1, xmm1, eax
|
| ; Multiply the truncated result by divisor (XMM2).
C5 F3 59 CA | vmulsd xmm1, xmm1, xmm2
|
| ; Subtract this temporary value (XMM1) from the original input (XMM0).
C5 FB 5C C1 | vsubsd xmm0, xmm0, xmm1
|
| ; See if the result is negative.
C5 F1 57 C9 | vxorpd xmm1, xmm1, xmm1 ; xmm1 = 0
C5 F9 2F C8 | vcomisd xmm1, xmm0 ; result < 0?
76 04 | jbe Finished
C5 FB 58 C2 | vaddsd xmm0, xmm0, xmm2 ; fixup negative modulo by adding divisor (XMM2)
|
| Finished:
C3 | ret
```
Of course, it would be even more efficient to multiply by the reciprocal, instead of dividing. But that means more precision is required to store the divisor, and would thus slightly increase the size of the code.
[Answer]
# PHP, 29 Bytes
```
<?=($v=$argn%360)>=0?:$v+360;
```
[Answer]
## Pyth - 5 bytes
```
%Q360
```
Would be shorter if `%360` meant `Q%360` instead of `360%Q`, but oh well...
[Answer]
## Python 2 REPL - 11 bytes
```
input()%360
```
If we've got a wierd input function, we might as well abuse it, right?
] |
[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/215719/edit).
Closed 3 years ago.
[Improve this question](/posts/215719/edit)
I have been going to [puzzling.se](https://puzzling.stackexchange.com/ "click me!"), and people over there write stuff in rot13 a lot, sot this gave me an idea:
Write a program that takes 2 inputs, a string and integer:
1. the message to encode or decode
2. how far to shift
You can input in a function call, and output in any legal way
twist:
it **must** work with any printable ascii character.
Example code:
```
def ceasar_cipher(message,shift):
o = ""
for n in message:
o+=(chr(ord(n)+shift))
return o
```
python 3 examples:
input:
>
> ceasar\_cipher(“hello, world”,13):
>
>
>
output:
>
> "uryy|9-\x84|\x7fyq."
>
>
>
This is code-golf, so shortest code in bytes wins.
The output should be a string
-Can raise an error if it will go past ASCII-characters, or just not shift said characters
Good luck!
[Answer]
# [BQN](https://mlochbaum.github.io/BQN/), 1 byte
Anonymous tacit infix function. Order of arguments doesn't matter.
```
+
```
[Try BQN!](https://mlochbaum.github.io/BQN/try.html#code=RuKGkCsKImhlbGxvLCB3b3JsZCIgRiAxMw==)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~4~~ 3 bytes
[crossed out 4 is still regular 4 ;(](https://codegolf.stackexchange.com/a/195414/94066)
*-1 byte thanks to [@Kevin Cruijssen](https://codegolf.stackexchange.com/users/52210/kevin-cruijssen).*
```
Ç+ç
```
[Try it online!](https://tio.run/##yy9OTMpM/f//cLv24eX//2ek5uTk6yiU5xflpHAZGgMA "05AB1E – Try It Online")
```
Ç+ç # full program
+ # increment...
Ç # charcodes of...
# implicit input
+ # by...
# implicit input
ç # convert to chars
# implicit output
```
[Answer]
# [K](https://aplwiki.com/k), 4 bytes
Anonymous tacit function taking two arguments in any order.
```
`c$+
```
[Try K!](https://kparc.io/kc/#f%3A%60c%24%2B%3Bf%5B13%3B%22hello%2C%20world%22%5D)
`+` add the arguments (this implicitly converts the characters to code points
…`$` cast to…
``c` character
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 32 bytes
```
f(s,n)char*s;{for(;*s;*s+++=n);}
```
[Try it online!](https://tio.run/##bVJtT8IwEP7Or7g0gbRsi@BLfJnoB@OvoMZgaWFxFmxHLML@uvPWDhjKkm338jz39O4qkpkQVaWojTUT84np23SjFoamaPRtFEUjzdKyWppMF9QDII8hGJLBpgP4YA4MjGCYehf5QOtYhrFBir97sIXJpaY5gwRhEEXZjlw/vryiNLNBKB9nL@yRdAW5I5y7riMsrmO9gVOKpXteLWqg1wPPgNEIZM0MgNJ/jSxWRoNJO2XnY5JputMNPRTSFq92jFzYkLnM80UMXwuTTy0p0784HXDDi6OUdEspCjn1SayyMuv19jbh7uZyy921Wn8elxJzKd6laTS5ez7n7vYJ3ysSQ9u/2PEOA9VT6ZqhehMHm33LhaKhD3bWuP3G95Ouke1phz1jmaZ5D3g5TLVW0ru0/peu6fC2UuNmp5ZFw1Yao2K5pgiIwbZ2pUJIt0LN2gknXcux@e4UkgfgBE17jPRHlnim/bBPHVogIFwgLyVPSgFqaRLv1yAO96WsfoTKJzNbJV@/ "C (gcc) – Try It Online")
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 40 bytes
```
FromCharacterCode[ToCharacterCode@#+#2]&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n277360oP9c5I7EoMbkktcg5PyU1OiQfhe@grK1sFKv2P6AoM69EwSE9WikjNScnX0ehPL8oJ0VJR8HQOPb/fwA "Wolfram Language (Mathematica) – Try It Online")
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal), `s`, 3 bytes
```
C+C
```
## Explained
```
C # Convert input string to a list of ord values
+ # Add implicit number shift
C # Convert back to a list of chars and output
```
If it must absolutely be a function:
# 7 bytes
```
λ2|C+C;
```
## Explained
```
λ2|C+C;
λ2| # Start a lambda with two arguments
C+C # Same as the full program
; # Close lambda
```
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 4 bytes
```
{n+m
```
[Run and debug it](https://staxlang.xyz/#c=%7Bn%2Bm&i=13,%22hello,+world%22)
a downside of `m` printing stuff with newline is that you need an explicit bracket.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 3 bytes
```
O+Ọ
```
[Try it online!](https://tio.run/##y0rNyan8/99f@@Hunv///2cAufk6CuX5RTkp/w2NAQ "Jelly – Try It Online")
## Explanation
```
O+Ọ Main Link
O chr->ord of left argument
+ add (left with right; implicit vectorization)
Ọ ord->chr of left argument
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 8 bytes
```
⭆η℅⁺Ｉθ℅ι
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRCO4BEil@yYWaGToKDgDJROTS1KLNAJySos1nBOLSzQKNXUU/ItSMvMSczQyNUHA@v9/Q2OujNScnHwdhfL8opyU/7plOQA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
η Second input
⭆ Map over characters and join
ι Current character
℅ Ordinal
⁺ Plus
θ First input
Ｉ Cast to integer
℅ Character
Implicitly print
```
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), 18 bytes
```
"$+"+T` -þ`!-ÿ
0A`
```
[Try it online!](https://tio.run/##K0otycxLNPz/X0lFW0k7JEFB9/C@BEXdw/u5DBwT/v83NObKSM3JyddRKM8vykkBAA "Retina – Try It Online") Works on all ISO-8859-1 characters as long as the result does not exceed U+00FF. Add 2 bytes to extend the output range to U+07FF. Add a further 2 bytes to extend the output range to UCS-2 characters up to U+FFFF. Explanation:
```
"$+"+`
```
Repeat the given number of times.
```
T` -þ`!-ÿ
```
Bump all the supported code points up by 1.
```
0A`
```
Delete the count.
[Answer]
# [Husk](https://github.com/barbuz/Husk), 6 bytes
```
mȯc+⁰c
```
[Try it online!](https://tio.run/##yygtzv7/P/fE@mTtR40bkv///2/yvyQjVaGwNDM5WyGpKL88TyEtv0IhqzS3oFghvyy1SAEknZNYVamQkp8OAA "Husk – Try It Online")
```
m # map over each element in arg 2
ȯ # 3 functions:
c # convert character to value
+⁰ # add arg 1
c # convert back to character
```
[Answer]
# [Ruby 2.7](https://www.ruby-lang.org/), ~~33~~ 30 bytes
```
->w,s{w.bytes.map{(_1+s).chr}}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf165cp7i6XC@psiS1WC83saC6JqlGI0m7WFMvOaOotvZ/gUJatHpGak5Ovo5CeX5RToq6joKhcex/AA "Ruby – Try It Online")
Returns an array of chars. TIO uses an older version of Ruby, whereas in Ruby 2.7, we've numbered parameters, which saves two bytes.
] |
[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/74557/edit).
Closed 7 years ago.
[Improve this question](/posts/74557/edit)
Similar to the [Catalogue of hello world](https://codegolf.stackexchange.com/q/55422/42503). I want to produce a catalogue of short ways to produce CSV.
# CSV Definition
In this case CSV meaning the more literal interpretation of;
A string representation of a list or array separated by commas.
The input types should not be mixed i.e [1, "hello"] is NOT valid input
The output should not start with a comma or end with a comma.
The output should not contain newline (in any way shape or form).
see example;
"John,Henry,Carol,Carl"
# Input
An array of variable length, containing only simple types.
The array representation is how your chosen language defines arrays or lists.
# Output
A string representation of the array separated with commas.
# Example
Input: ["John", "Henry", "Carol", "Mike"]
Output: "John,Henry,Carol,Mike"
# How do I win?
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest answer (in bytes) in wins.
## 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:
```
## [><>](http://esolangs.org/wiki/Fish), 121 bytes
```
```
/* Configuration */
var QUESTION_ID = 74557; // Obtain this from the url
// It will be like http://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 "http://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 "http://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}
#answer-list {
padding: 10px;
width: 290px;
float: left;
}
#language-list {
padding: 10px;
width: 290px;
float: left;
}
table thead {
font-weight: bold;
}
table td {
padding: 5px;
}
```
```
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">
<div id="language-list">
<h2>Shortest Solution by Language</h2>
<table class="language-list">
<thead>
<tr><td>Language</td><td>User</td><td>Score</td></tr>
</thead>
<tbody id="languages">
</tbody>
</table>
</div>
<div id="answer-list">
<h2>Leaderboard</h2>
<table class="answer-list">
<thead>
<tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>
</thead>
<tbody id="answers">
</tbody>
</table>
</div>
<table style="display: none">
<tbody id="answer-template">
<tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
</tbody>
</table>
<table style="display: none">
<tbody id="language-template">
<tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
</tbody>
</table>
```
[Answer]
# JavaScript (ES6), 7 bytes
```
a=>a+""
```
an array cast to a string has `,`s implicitly inserted.
[Answer]
# TeaScript, 0 bytes
An empty TeaScript program does this.
TeaScript implicitly adds the input to the operator stack.
The result of the operator stack is outputted. In this case it's the input, due to JavaScript's nature, when it's casted to a string, commas are added.
[Try it online](http://vihan.org/p/teascript/#?code=%22%22&inputs=%5B%22%5B%5C%221%5C%22,%5C%222%5C%22,%5C%223%5C%22%5D%22%5D&opts=%7B%22ev%22:true,%22debug%22:false,%22nox%22:false%7D)
[Answer]
# Python 3, 8 bytes
Saved 12 bytes thanks to DSM.
This isn't even close to a complete implementation of the CSV, but it satisfies the letter of what the challenge is looking for.
```
','.join
```
[Answer]
## Haskell, 16 bytes
```
tail.((',':)=<<)
```
Usage example: `tail.((',':)=<<) $ ["john", "henry", "carol", "Mike"]` -> `"john,henry,carol,Mike"`.
[Answer]
# Pyth, 4 bytes
```
j\,Q
```
Evaluates input and joins by comma. Nothing much to say.
[Try it online.](http://pyth.herokuapp.com/?code=j%5C%2CQ&input=%5B%22test%22%2C%22test%22%2C%22test%22%5D&debug=0)
[Answer]
# ùîºùïäùïÑùïöùïü, 1 char / 2 bytes
```
ï
```
`[Try it here (Firefox only).](http://molarmanful.github.io/ESMin/interpreter3.html?eval=true&input=%5B1%2C2%5D&code=%C3%AF)`
This one just outputs the input; however, with arrays, the brackets and quotes are discarded, leaving only the items and commas.
[Answer]
# [DUP](https://esolangs.org/wiki/DUP), 29 bytes
```
[`$~][$'"=^'[=2√∏']=||[][,]?]#
```
`[Try it here.](http://www.quirkster.com/iano/js/dup.html)`
Takes input from STDIN as something like `["asdf","adsf","fdsa"]` because DUP doesn't really have arrays that can hold strings.
# Explanation
```
[ ][ ]# {while loop}
`$~ {read an input char until end of input (-1)}
$'"=^'[=2√∏']=|| {check if input char is [,], or "}
[][ ]? {conditional}
, {if not, output char}
```
[Answer]
# Python 2, 10 bytes (or may be 8, without assignment)
```
x=','.join
```
Test
```
>>> x(["John", "Henry", "Carol", "Mike"])
'John,Henry,Carol,Mike'
```
[Answer]
## PowerShell, 16 bytes
```
$args[0]-join','
```
Takes input, `-join`s 'em together. PowerShell supports mixed array types without anything special.
**Example**
```
PS C:\Tools\Scripts\golfing> .\csv-for-fun.ps1 ('Doorknob',33,'Martin','Peter')
Doorknob,33,Martin,Peter
```
---
**Additionally**
If you want an *actual* CSV output, PowerShell also has the excellent [Export-CSV](https://technet.microsoft.com/en-us/library/hh849932.aspx) command. For example, `('Doorknob',33,'Martin','Peter')|epcsv -Path .\c.csv` (with `epcsv` as an alias).
[Answer]
# Jelly, 3 bytes
```
j”,
```
[Try it online!](http://jelly.tryitonline.net/#code=auKAnSw&input=&args=WyJKb2huIiwgIkhlbnJ5IiwgIkNhcm9sIiwgIk1pa2UiXQ)
[Answer]
## POSIX sh, 15 bytes
```
IFS=,
echo "$*"
```
### Example
```
# bash, dash, zsh, ksh, mksh... any basically POSIX-compatible shell.
dash -c 'IFS=,;echo "$*"' -- 'Foo B' ar baz
# -> Foo B,ar,baz
```
### Explanation
`$*` is basically `argv[1:].join(IFS[0])`. Double-quoted to avoid further splitting and globbing, which in our case will give us back `a b c`. If you passed something like `a b '*'` in instead, you will find all your files listed due to the globbing.
The positional parameters, i.e. `argv[1:]`, is the basic way to represent arrays in pure POSIX shell scripts. Functions are sometimes used to create new space for holding such parameter lists. You can only have one array working at a time using this technique.
[Answer]
# [Milky Way 1.6.5](https://github.com/zachgates7/Milky-Way), 10 bytes
```
'C"'[]"-G!
```
---
### Explanation
```
'C ` push input to the stack as a list of characters
"'[]" ` push a string containing a single quote & square brackets
- ` remove the characters in the TOS from the STOS
G! ` output the remaining characters
```
---
### Usage
```
$ ./mw <path-to-code> -i "['John','Phil','Dave','Matt H.','Matt D.']"
John,Phil,Dave,Matt H.,Matt D.
```
Input should be provided as the string of an array, containing no double quotes.
[Answer]
# Perl 6, 12 bytes
```
{.join: ','}
```
 
[Answer]
# [Dyalog APL](http://goo.gl/9KrKoM), 11 bytes
```
1↓∊',',¨⍕¨⎕
```
Works even on numbers and mixed datatypes (remove `⍕¨` if unnecessary`). Takes list of strings as prompted input
`‚éï` prompt for and evaluate input
`',',¨` prepend comma to each
`‚àä` flatten
`1‚Üì` remove initial comma
[Answer]
# Retina, 3 bytes
```
¶
,
```
`[Try it online!](http://retina.tryitonline.net/#code=wrYKLA&input=Sm9obgpIZW5yeQpDYXJvbApNaWtl)`
Takes newline-separated list. If this isn't valid, here's another 6-byte solution that takes a more... *conventional*... format.
```
["{}]
<empty>
```
`[Try it online!](http://retina.tryitonline.net/#code=WyJ7fV0K&input=eyJhYiIsImJjIn0)`
[Answer]
## Lua, 42 Bytes
Simple use of the `table.concat()` function, limiting the type-mixing possibility to only numbers and strings.
```
function f(t)print(table.concat(t,","))end
```
[Answer]
# Mathematica, ~~19~~ ~~30~~ 28 bytes
```
""<>Riffle[ToString/@#,","]&
```
`#~StringRiffle~","&` works if only strings will be input (which nobody actually knows)
[Answer]
## PHP, ~~37~~ 34 bytes
```
function i($a){echo join(",",$a);}
```
The vast majority of the size comes from setting the function. As a simple call it's just `join(",",$a)`.
If we allow the array to come from the URL:
## PHP, ~~24~~ 21 bytes
```
echo join(",",$_GET);
```
[Answer]
# [Gogh](https://github.com/zachgates7/Gogh), 1 byte
```
s
```
Usage:
```
$ ./gogh noa "s" 'John Mike Henry'
```
See the wiki to understand Gogh's array input.
---
### Explanation
```
“ Implicit input ”
s “ String conversion ”
“ Implicit output ”
```
] |
[Question]
[
**This question already has answers here**:
[1/N probability](/questions/66922/1-n-probability)
(49 answers)
Closed 6 years ago.
>
> ***Note**: There was not a vanilla challenge to actually flip a coin, even though there were mentions about flipping coins a lot of places. Even though there is a challenge to generate a random number from 1 to N, I suspect this is not a dupe. These questions ask for random numbers from 1 to N, while this ask for just truthy/falsy.*
>
>
>
Flipping a coin is widely used in selecting decisions. But, I do not have a coin (only bills and credit/debit cards).
So, your program has to flip a coin for me!
---
# I/O
## Input:
None.
## Output:
A truthy/falsy value depending on the coin's state(heads/tails). It does not have to be uniform, seeding by timestamp is allowed. Also, we do not count neither-heads-nor-tails, and assume the coin only has two sides.
[Answer]
# [Python 2](https://docs.python.org/2/), ~~18~~ ~~17~~ ~~15~~ 14 bytes
```
0/(id(0)&4096)
```
[Try it online!](https://tio.run/nexus/python3#@2@gr5GZomGgqWZiYGmm@f//17x83eTE5IxUAA "Python 2 – TIO Nexus") Output is via exit code, so check the *Debug* drawer.
If 50/50 chance isn't required, these shorter versions will work as well.
```
0/(id(0)%3) # 11 bytes, awfully biased
0/(id(0)>>25) # 13 bytes, even more biased
0/(id(0)%6<3) # 13 bytes, fair enough for most practical purposes
```
### How it works
In CPython 2.7.12, `id(1)` yields the memory location of the constant **1** as a 32-bit integer with the following pattern.1
```
000000yxxxxxxxxxxxxx000110100000
```
**y** isn't constant, but it's biased towards **0**. All **x** bit seem to occur with the same probability. I ran the program 100,000 times and these were the distributions.
```
Bit Zeroes Ones
0 100000 0
1 100000 0
2 100000 0
3 100000 0
4 100000 0
5 0 100000
6 100000 0
7 0 100000
8 0 100000
9 100000 0
10 100000 0
11 100000 0
12 50125 49875
13 50319 49681
14 50001 49999
15 50164 49836
16 50095 49905
17 50072 49928
18 49780 50220
19 50056 49944
20 49910 50090
21 50038 49962
22 50103 49897
23 49811 50189
24 50106 49894
25 80950 19050
26 100000 0
27 100000 0
28 100000 0
29 100000 0
30 100000 0
31 100000 0
```
If the twelfth least significant bit is set, `id(0)&4096` yields **1** and the program exits with status code **1**. However, if it is *not* set, `id(0)&4096` yields **0**, a *ZeroDivisionError* is raised, and the program exits with status code **1**.
---
1 I've verified anything I couldn't find in the docs empirically. Other implementations may behave differently.
[Answer]
# [MATL](https://github.com/lmendo/MATL), 3 bytes
```
rEk
```
This outputs `0` or `1` with the same probability.
[Try it online!](https://tio.run/nexus/matl#@1/kmv3//9e8fN3kxOSMVAA "MATL – TIO Nexus")
### Explanation
```
r % Random number uniformly distributed on the interval (0,1)
E % Multiply by 2
k % Round down
```
[Answer]
# Pyth, 2 bytes
```
O2
```
Outputs 0 for heads, 1 for tails.
Similarity to any real-world company only incidental.
[Try it!](https://pyth.herokuapp.com/?code=O2&test_suite=1&test_suite_input=%0A%0A%0A%0A%0A%0A&debug=0)
[Answer]
## JavaScript (ES6), 13 bytes
```
_=>new Date%2
```
### Test snippet
```
let f =
_=>new Date%2
```
```
<button onclick="console.log(f())">Flip</button>
```
[Answer]
# Powershell, 8 Bytes
```
random 2
```
outputs either 0 or 1 randomly.
[Answer]
# [Perl 6](https://perl6.org), 11 bytes
```
{Bool.pick}
```
[Try it](https://tio.run/nexus/perl6#Ky1OVSgz00u25sqtVFArSS3KtbJJy8ks0E3UTc7PzLNTsP1f7ZSfn6NXkJmcXfu/OLFSAUlaIS2/SCHO0MD6PwA "Perl 6 – TIO Nexus")
## Explanation:
* `Bool` is an enum of `True` and `False`
* `.pick` picks an element at random from a list
* `{…}` in this case makes it a lambda
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 3 bytes
```
K%2
```
[Try it online!](https://tio.run/nexus/japt#@@@tavT//9e8fN3kxOSMVAA "Japt – TIO Nexus") (Output cache disabled for obvious reasons)
Outputs `0` or `1` with equal probability. `K` is equivalent to `new Date()` in JavaScript, and `%2` takes the timestamp mod 2.
---
Alternatively:
```
½>Mr
```
This one generates a random float `x` between 0 and 1, and outputs `.5>x`. [Try it online!](https://tio.run/nexus/japt#@@@tavT//9e8fN3kxOSMVAA "Japt – TIO Nexus")
[Answer]
# [CJam](https://sourceforge.net/p/cjam), 3 bytes
```
2mr
```
[Try it online!](https://tio.run/nexus/cjam#@2@UW/T//9e8fN3kxOSMVAA "CJam – TIO Nexus")
**Explanation**
```
2 e# Push 2
mr e# Random integer from 0 to n-1
```
[Answer]
# PHP, 13 bytes
```
<?=rand(0,1);
```
Outputs a pseudo-random `0` or `1` value.
[Test online](http://sandbox.onlinephpfunctions.com/code/adde1730418c37703327a8d08c8a5cddcf791a72)
[Answer]
# [Octave](https://www.gnu.org/software/octave/), 10 bytes
```
@()rand<.5
```
Anonymous fuction that takes no inputs and returns `0` or `1`.
[Try it online!](https://tio.run/nexus/octave#@@@goVmUmJdio2f6P03BViExr9iaKy2/SCHP1tDK0EBHISWzuEAjTUNTU0chNS/l/9e8fN3kxOSMVAA "Octave – TIO Nexus")
[Answer]
# Jelly, 3 bytes
```
2ḶX
```
[Try it online!](https://tio.run/nexus/jelly#@2/0cMe2iP//v@bl6yYnJmekAgA)
[Answer]
# [><>](https://esolangs.org/wiki/Fish), ~~14~~ 11 bytes
```
x0n;n0
>1n;
```
[Try it online!](https://tio.run/nexus/fish#@19hkGedZ8BlZ5hn/f//17x83eTE5IxUAA "><> – TIO Nexus")
Outputs either `0` or `1`
[Answer]
# [Röda](https://github.com/fergusq/roda), 13 bytes
```
randomBoolean
```
[Try it online!](https://tio.run/nexus/roda#y03MzFOo/l@UmJeSn@uUn5@Tmpj3v/b/17x83eTE5IxUAA "Röda – TIO Nexus")
This is a boring builtin.
[Answer]
# [\*><>](http://esolangs.org/wiki/starfish), 6 bytes
```
x0n;n1
```
[Online interpreter](https://starfish.000webhostapp.com?script=B4Bgdg3GCMQ)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~4~~ 3 bytes
```
T.R
```
[Try it online!](https://tio.run/nexus/05ab1e#@x@iF/T//9e8fN3kxOSMVAA "05AB1E – TIO Nexus")
Explanation:
```
T 10
.R Random choice (breaks into individual digits)
```
[Answer]
# [Cubix](https://github.com/ETHproductions/cubix), 7 bytes
```
w>O@D1.
```
Outputs `0` with 1/3 probability, `1` with 2/3 probability. [Try it online!](https://tio.run/nexus/cubix#@19u5@/gYqj3///XvHzd5MTkjFQA "Cubix – TIO Nexus")
I think this is the first time I've had to pad the source code with no-ops to make the cube the correct size...
### Explanation
Cubix is a 2D stack-based esolang wrapped around a cube. The source code won't fit onto a size-1 cube, and so it gets wrapped around a size-2 cube, with the following cube net:
```
w >
O @
D 1 . . . . . .
. . . . . . . .
. .
. .
```
The IP (instruction pointer) is then sent into action, starting at the top-left corner of the left-most face, and facing east. The first instruction it hits is `D`, which points the IP in a random direction. This isn't the best possible source of randomness for this challenge, but it's the only one Cubix has.
If the IP is pointed north, it wraps onto the `w` on the top face, which moves the IP one position to the right (south at this point). `O` outputs the top item on the stack as a number (`0` if the stack is empty), and `@` ends the program.
If the IP is pointed south, it wraps around various faces before hitting the `>` on the top face. It's going west at this point, and `>` points the cursor east, sending it back to the `D`, which starts the whole process over.
If the IP is pointed east or west, it simply wraps around the third row of the above diagram, hitting the `1` at some point in the middle. When it gets back to the `D`, the process is started again as before, but when the IP eventually gets sent north, `O` outputs `1` instead of `0`.
So each time `D` is hit, there's a 2/4 chance that the output will be `1`, and a 1/4 chance that it will be `0`. The other 1/4 is simply the chance of the process starting over, and so if we sum the infinitely shrinking chances of each output, we get 2/3 for `1` and 1/3 for `0`.
[Answer]
# [Gol><>](https://github.com/Sp3000/Golfish/wiki), 3 bytes
```
xh1
```
[Online interpreter](https://golfish.herokuapp.com?code=xh1)
[Answer]
# [Befunge-98](https://github.com/catseye/FBBI), 6 bytes
```
#1?0>q
```
[Try it online!](https://tio.run/nexus/befunge-98#@69saG9gV/j//9e8fN3kxOSMVAA "Befunge-98 – TIO Nexus")
Exits with exit code 0 or 1.
## Explanation
Program flow in Befunge is a bit difficult to follow. The Instruction Pointer (IP) starts on the left, moving towards the right. The first instruction `#` tells it to ignore the next instruction, so it jumps to `?`. This randomly sets the IP moving either up, down, left, or right. If it moves up or down, it "wraps around" and hits the `?` again. If it moves right, 0 is pushed onto the stack and then `q` exits with the topmost value of the stack (0) as the exit code. If the IP moves left, 1 is pushed onto the stack, `q` is jumped over, `>` sets the IP moving to the right again, and then `q` exits the program with the topmost value of the stack (1) as the exit code.
I believe that this code also works in Unefunge-98, Trefunge-98, and possibly all members of the Funge-98 family. I have not tested any of these claims though.
] |
[Question]
[
Given the following list of numbers, find the group of
sequential positive numbers with the highest sum.
Example input:
```
12 2 35 -1 20 9 76 5 4 -3 4 -5 19 80 32 -1
```
Example output:
```
131
```
The most succinct code wins.
My approach via Perl is 87 chars (with input as command-line args):
```
print((sort { $b <=> $a } do { push @s, $_ > 0 ? pop(@s) + $_ : 0 for @ARGV; @s })[0]);
```
[Answer]
## APL, 35 characters
```
i←⎕⋄⌈/{{+/⍵/⍨∧\⍵>0}⍵↓i}¨0,(i≤0)/⍳⍴i
```
I used Dyalog APL for this. `⎕IO` should be set to its default of `1`.
Example (note that high-minus, `¯`, must be used instead of regular minus):
```
i←⎕⋄⌈/{{+/⍵/⍨∧\⍵>0}⍵↓i}¨0,(i≤0)/⍳⍴i
⎕:
12 2 35 ¯1 20 9 76 5 4 ¯3 4 ¯5 19 80 32 ¯1
131
```
Explanation (roughly right-to-left for each expression):
* First, we get (and evaluate) the input: `i←⎕`. (`⋄` separates expressions in a single statement.)
* `(i≤0)/⍳⍴i` is an idiom to get the list of the locations of elements of `i` that are `≤0`.
+ `i≤0` returns a vector of binary values, where each element is `1` if the corresponding element in `i` is `≤0`, and `0` otherwise.
+ `⍳⍴i` returns a list of integers, from 1 to the shape (length) of `i`.
+ The replication function, `/`, replicates each value in its right argument `n` times, where `n` is the corresponding element in its left argument. Because we have a binary list, this just includes or excludes elements (replicating them 0 or 1 times).
+ We tack a `0` on the beginning, using the concatenation operator (`,`).
* Now, using the example input, we have the vector `0 4 10 12 16`. We use the each operator, `¨`, to map a function (its left operand) to each element of this list.
* The function is a *direct* function (basically, an anonymous function), and its definition is surrounded with curly braces. Its right argument is represented by the omega symbol, `⍵`.
* For each element of our vector:
+ The outermost function, `{{ ... }⍵↓i}`, returns the vector `i`, with `⍵` elements dropped (`↓`) from the beginning. This is then fed to...
+ The innermost function, `{+/⍵/⍨∧\⍵>0}`, in slightly less golfed form is `{+/(∧\⍵>0)/⍵}`.
+ `(∧\⍵>0)/⍵` is similar to the aforementioned idiom. First we generate a list of elements in `⍵` that are above `0`. Then, we use the scan operator, `\`, along with the bitwise-AND function, `∧`, to return the list (⍵1 , ⍵1 ∧ ⍵2 , ⍵1 ∧ ⍵2 ∧ ⍵3 , ...). In other words, this list consists of 1's up until the first non-positive element, where it is then all 0's. We use replication as before.
+ We now use the *reduction* operator, (also) represented by `/`, along with the addition function, `+`, to fold all positive elements in the current list, up to (but not including) the first non-positive one.
* Lastly, we fold again, this time with the maximum function, `⌈`.
Here are snapshots showing the results of some stages:
```
i≤0
0 0 0 1 0 0 0 0 0 1 0 1 0 0 0 1
⍳⍴i
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
0,(i≤0)/⍳⍴i
0 4 10 12 16
{⍵↓i}¨0,(i≤0)/⍳⍴i
12 2 35 ¯1 20 9 76 5 4 ¯3 4 ¯5 19 80 32 ¯1 20 9 76 5 4 ¯3 4 ¯5 19 80 32 ¯1 4 ¯5 19 80 32 ¯1 19 80 32 ¯1
{{(∧\⍵>0)}⍵↓i}¨0,(i≤0)/⍳⍴i
1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 1 0
{{(∧\⍵>0)/⍵}⍵↓i}¨0,(i≤0)/⍳⍴i
12 2 35 20 9 76 5 4 4 19 80 32
{{+/(∧\⍵>0)/⍵}⍵↓i}¨0,(i≤0)/⍳⍴i
49 114 4 131 0
```
Hopefully some of this makes a bit of sense!
[Answer]
# CJam, 16 byte
This answer is not eligible for the green checkmark, as CJam is much newer than this challenge (and this answer relies on even newer features). However, I thought this was a really neat approach (and hey, I'm beating APL by quite a margin!), so I wanted to post it anyway.
```
l~]0fe>0a%::+$W=
```
[Test it here.](http://cjam.aditsu.net/#code=l~%5D0fe%3E0a%25%3A%3A%2B%24W%3D&input=12%202%2035%20-1%2020%209%2076%205%204%20-3%204%20-5%2019%2080%2032%20-1)
## Explanation
```
l~] "Read input, eval, wrap in array.";
0fe> "Map max(0,x) onto the list, turning all non-positive numbers into 0.";
0a% "Split the list on zeroes - i.e. split into positive subarrays.";
::+ "Map a fold of + onto the array - i.e. compute the sum of each subarray.";
$W= "Sort and get the last element - i.e. the maximum.";
```
[Answer]
## Python 3, 93 80 79 71 chars
```
a=b=0
for i in map(int,input().split()):b+=i;b*=i>0;a=max(a,b)
print(a)
```
Thanks to D C for pointing out how to save 8(!) characters from this:
```
a=b=0
for i in map(int,input().split()):b+=i;a=[a,b][b>a];b=[0,b][i>0]
print(a)
```
Saved one character by indexing by true/false rather than if statements.
It is much less readable than the equivalent 80 char version:
```
a=b=0
for i in map(int,input().split()):
b+=i
if b>a:a=b
if i<=0:b=0
print(a)
```
The 93 character version converted to int later in the game:
```
print(max(sum(map(int,s.split()[1:]))for s in('-1 '+input().replace(' 0','-1')).split('-')))
```
[Answer]
## Python 3 (92)
Reads the list of numbers from stdin.
```
m,s=0,[]
for x in map(int,input().split()):
if x<0:s+=[m];m=0
else:m+=x
print(max([m]+s))
```
[Answer]
## Perl, 45 chars
```
say+(sort{$b-$a}map$p=$_>0?$_+=$p:0,@ARGV)[0]
```
(Uses `say`, so needs to be run with perl 5.10+ and the `-M5.010` (or `-E`) switch.)
[Answer]
# APL, 22 20
```
⌈/∊(+\×{∧\0<⍵})¨,⍨\⎕
```
To test it online:
```
{⌈/∊(+\×{∧\0<⍵})¨,⍨\⍵}
```
[Try it here.](http://tryapl.org/?a=%7B%u2308/%u220A%28+%5C%D7%7B%u2227%5C0%3C%u2375%7D%29%A8%2C%u2368%5C%u2375%7D12%202%2035%20%AF1%2020%209%2076%205%204%20%AF3%204%20%AF5%2019%2080%2032%20%AF1&run)
### Explanation
```
{ ,⍨\⍵} ⍝ Get a list of reversed prefixes.
{ 0<⍵} ⍝ Check if each item is >0.
{∧\0<⍵} ⍝ Check if each prefix is all >0.
+\ ⍝ Sum of each prefix.
(+\×{∧\0<⍵}) ⍝ Sum * all>0 for each prefix.
{ (+\×{∧\0<⍵})¨,⍨\⍵} ⍝ Apply that to each reversed prefixes (So the prefixes of
⍝ reversed prefixes are reversed suffixes of prefixes of
⍝ the original string).
{ ∊(+\×{∧\0<⍵})¨,⍨\⍵} ⍝ Flatten the array.
{⌈/∊(+\×{∧\0<⍵})¨,⍨\⍵} ⍝ Find the maximum.
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt) `-hx`, ~~9~~ 6 bytes
*-3 bytes from @Shaggy*
```
ô<0 ñx
```
[Try it online!](https://tio.run/##y0osKPn///AWGwOFwxsr/v@PNjTSUQAiY1MdBV1DINNAR8FSR8HcTEcBKGICFDSGUECeIVDCAihvbARSG6ugm1EBAA "Japt – Try It Online")
[Answer]
## Perl: 56 53 characters
Thanks to Ilmari Karonen
```
push@s,$_>0?$_+pop@s:0for@ARGV;say+(sort{$b-$a}@s)[0]
```
[Answer]
## Racket, 108 chars
Once golfed, it gives 133 chars with intermediary "f", or 108 if you use "g" directly.
```
(define f
(λ (l)
(g l 0 0)))
(define g
(λ (l M c)
(cond
((null? l) (max M c))
((> 0 (car l)) (g (cdr l) (max M c) 0))
(else
(g (cdr l) M (+ (car l) c))))))
(f '(12 2 35 -1 20 9 76 5 4 -3 4 -5 19 80 32 -1)) ;-> 131
```
Where "l" is the list of values, "M" is the maximum sum yet encountered, and "c" is the current sum.
Golfed:
```
(define f(λ(l)(g l 0 0)))(define g(λ(l M c)(cond((null? l)(max M c))((> 0(car l))(g(cdr l)(max M c)0))(else(g(cdr l)M(+(car l)c))))))
```
[Answer]
# K, 20
```
{max@+/'1_'(&x<0)_x}
```
Finds the indices where x<0, cuts the list at those indices, drops the negative numbers, sums and finds the maximum.
```
k){max@+/'1_'(&x<0)_x}12 2 35 -1 20 9 76 5 4 -3 4 -5 19 80 32 -1
131
```
Equivalent in q:
```
{max sum each 1_'(where x<0)_x}
```
[Answer]
### Scala: 102 chars
```
def s(x:Seq[Int],y:Int=0):Int={
if(x==Nil)y else
if(x(0)<0)math.max(y,s(x.tail))else
s(x.tail,y+x(0))}
val data = List (12, 2, 35, -1, 20, 9, 76, 5, 4, -3, 4, -5, 19, 80, 32, -1)
s(data)
```
ungolfed:
```
def sumup (xs: Seq[Int], sofar: Int=0): Int = {
if (xs.isEmpty) sofar else
if (xs.head < 0) sofar + sumup (xs.tail) else
sumup (xs.tail, sofar + xs.head)
}
sumup (List (12, 2, 35, -1, 20, 9, 76, 5, 4, -3, 4, -5, 19, 80, 32, -1))
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 8 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
Œʒß0›}Oà
```
[Try it online](https://tio.run/##MzBNTDJM/f//6KRTkw7PN9ALrvU/vOD//2hDIx0jHWNTHV1DHSMDHUsdczMdUx0THV1jEGGqY2ipY2GgY2wElI8FAA).
**Explanation:**
```
Π# Get all sub-lists of the input-list
# i.e. [2,4,-5,7]
# → [[2],[2,4],[2,4,-5],[2,4,-5,7],[4],[4,-5],[4,-5,7],[-5],[-5,7],[7]]
ʒ } # Filter this list of lists by:
ß # Take the smallest value of the inner list
# i.e. [4,-5,7] → -5
0› # Check if it's larger than 0
# i.e. -5>0 → 0 (falsey)
O # Take the sum of each remaining item
# i.e. [[2],[2,4],[4],[7]] → [2,6,4,7]
à # And take the maximum of the sums
# i.e. [2,6,4,7] → 7
```
[Answer]
# **Perl6** with MoarVM, 53 chars
```
@a[$_ <0??++$i-$i!!$i||++$i]+=$_ for lines;@a.max.say
```
[Answer]
# PHP, 56 bytes
```
while(~$n=$argv[++$i])$n<0?$k++:$r[$k]+=$n;echo max($r);
```
Run with `-nr`.
[Answer]
# Java 8, ~~72~~ 62 bytes
```
l->{int c=0,m=0;for(int i:l){c=i>0?c+i:0;m=m<c?c:m;}return m;}
```
Try it online [here](https://tio.run/##VVBNT4QwEL37K@ZIY2Fh8ZMubDya6GmPxkPtdkmxLdiWjRvCb8dhxahNOx/vTd7LtOFHHredtM3@fer6N60ECM29h2euLAwXgEfZIN2BCwk7@bFgCw6Gf0YNiiR9UDp5Uj5sHnG8lq5CvusDYef58RwXBx94wHRs1R4FlI12wSlbv7wCd7UnfyxmQ4@vhEnH1TA7ijKlpkzZoXXR3KtCk0GUqkq34lIVKTOl2YitKAwbnQy9s4DV9KPIfrVPPkiTtH1IOrQP2kZolfzf6ME5fvIJ9/NqUbamgDe/phBnWKYU7inc3lBA5ArB/DthlyFxh3y@nmcJIQxWK8jybPmOcfoC).
Ungolfed:
```
l -> { // lambda taking a List as argument and returning an int
int c = 0, m = 0; // two sums: c is the sum of the current run of positive integers; m is the maximum sum found so far
for(int i : l) { // for each element in the list:
c = i > 0 ? c + i : 0; // if the number is positive, extend the current run by adding it to the sum; otherwise reset the sum to zero
m = m < c ? c : m; // if the maximum recorded so far is smaller than the current sum, record the current sum as the new maximum
}
return m; // return the maximum
}
```
[Answer]
# C (gcc/tcc), 69 bytes
```
c,m;f(int*a,int*b){c=m=0;for(;a<b;++a){c=*a>0?c+*a:0;m=m<c?c:m;}a=m;}
```
Port of my Java [answer](https://codegolf.stackexchange.com/a/169641/79343). Try it online [here](https://tio.run/##LUxdD4IwDHz3VzQkJhsrcYCfjMkPUR/KFMPDwKBPEn47dmrTXK9317rk7tw8O/SmEW33igkD1nJ01lttmn4QhsraKEVBi@moK6diKrTx1peucoU3E1mGmS/BU9uBkDAugCsodLqAhTHNELjzDUKSMtUIB4TdFoGVNYv5b/CWsrFnP89CdjLfV4@BnzUiWl7PXYTQCEIg9Wzft565XP0Zh6SUZjHNHw).
[Answer]
## [Perl 5](https://www.perl.org/) +`-pa -MList::Util+(max)`, 28 bytes
```
$_=max map/-/?$-=0:$-+=$_,@F
```
[Try it online!](https://tio.run/##K0gtyjH9/18l3jY3sUIhN7FAX1ffXkXX1sBKRVfbViVex8Ht/39DIwUjBWNTBV1DBSMDBUsFczMFUwUTBV1jEGGqYGipYGGgYGwElP@XX1CSmZ9X/F@3IPG/rq9PZnGJlVVoSWaOtgbQfE0A "Perl 5 – 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/2370/edit).
Closed 9 years ago.
[Improve this question](/posts/2370/edit)
Create a self-replicating Hello World Program. (The program has the ability to use the compiler, if you want).
For example:
```
void main()
{
printf("Hello, World!");
DuplicateFile("main.exe", "main2.exe");
}
```
---
**Alternate challenge:** A "quine" Hello World Program.
[Answer]
## Bash - 43
```
echo $(echo Hello, World! >&2)$BASH_COMMAND
```
This prints "Hello, World!" on standard error, and itself on standard output.
For fun:
```
$ ./replicate-hello.bash
Hello, World!
echo $(echo Hello, World! >&2)$BASH_COMMAND
$ ./replicate-hello.bash | bash
Hello, World!
Hello, World!
echo $(echo Hello, World! >&2)$BASH_COMMAND
$ ./replicate-hello.bash | bash | bash
Hello, World!
Hello, World!
Hello, World!
echo $(echo Hello, World! >&2)$BASH_COMMAND
$ bash <<< $(echo ./replicate-hello.bash; \
for ((i=0;i<100;i++)) ; do echo "| bash"; done)
Hello, World!
Hello, World!
Hello, World!
Hello, World!
... snip ...
Hello, World!
Hello, World!
Hello, World!
echo $(echo Hello, World! >&2)$BASH_COMMAND
```
[Answer]
## PHP, 13
```
Hello, world!
```
The only way to have a program that prints both "Hello, world!" and itself is this.
Edit: note that the question was not quite as clear when I wrote this.
[Answer]
## Windows Batch file
```
@echo Hello World
@copy "%~dpnx0" "%~dpn02%~x0" >nul 2>&1
```
[Answer]
# Erlang 1342 chars, 3 lines
Not sure if I've understood the question correctly here, I ended up writing a quine that writes to another file...
```
-module(hi).
-export([h/0]).
h()->io:fwrite("Hello World!"),P=[45,109,111,100,117,108,101,40,104,105,41,46,10,45,101,120,112,111,114,116,40,91,104,47,48,93,41,46,10,104,40,41,45,62,105,111,58,102,119,114,105,116,101,40,34,72,101,108,108,111,32,87,111,114,108,100,33,34,41,44,80,61],Q=[44,102,105,108,101,58,119,114,105,116,101,95,102,105,108,101,40,34,104,105,50,46,101,114,108,34,44,80,41,44,102,105,108,101,58,119,114,105,116,101,95,102,105,108,101,40,34,104,105,50,46,101,114,108,34,44,105,111,95,108,105,98,58,102,119,114,105,116,101,40,34,126,119,34,44,91,80,93,41,44,91,97,112,112,101,110,100,93,41,44,102,105,108,101,58,119,114,105,116,101,95,102,105,108,101,40,34,104,105,50,46,101,114,108,34,44,32,34,44,81,61,34,44,91,97,112,112,101,110,100,93,41,44,102,105,108,101,58,119,114,105,116,101,95,102,105,108,101,40,34,104,105,50,46,101,114,108,34,44,105,111,95,108,105,98,58,102,119,114,105,116,101,40,34,126,119,34,44,91,81,93,41,44,91,97,112,112,101,110,100,93,41,44,102,105,108,101,58,119,114,105,116,101,95,102,105,108,101,40,34,104,105,50,46,101,114,108,34,44,81,44,91,97,112,112,101,110,100,93,41,46],file:write_file("hi2.erl",P),file:write_file("hi2.erl",io_lib:fwrite("~w",[P]),[append]),file:write_file("hi2.erl", ",Q=",[append]),file:write_file("hi2.erl",io_lib:fwrite("~w",[Q]),[append]),file:write_file("hi2.erl",Q,[append]).
```
I'm currently learning Erlang, so it was a good learning experience anyway.
[Answer]
# Javascript, 89 bytes
I'm not quite sure if this is what you're asking, but this program has "hello world" in it and outputs itself.
```
//hello world
var f=function (){return "//hello world\nvar f="+f.toString()+";f();"};f();
```
[Answer]
# Java (1045)
[I've done this before.](https://gist.github.com/Ming-Tang/968033)
```
import java.io.*;
import javax.tools.*;
class H1 {
static final char Q=34;
static final int N=1;
public static void main(String[]a)throws Exception{
String fn="H"+(N+1)+".java";
BufferedWriter out=new BufferedWriter(new FileWriter(fn));
String s="import java.io.*;import javax.tools.*;class H%d{static final char Q=34;static final int N=%d;public static void main(String[]a)throws Exception{String fn=%cH%c+(N-1)+%c.java%c;BufferedWriter out=new BufferedWriter(new FileWriter(fn));String s=%c%s%c;out.write(String.format(s,N+1,N+1,Q,Q,Q,Q,Q,s,Q,Q,Q,Q,Q));out.close();JavaCompiler c=ToolProvider.getSystemJavaCompiler();c.run(null,null,null,fn);Class.forName(%cH%c+(N+1)).getMethod(%cmain%c,a.getClass()).invoke(null,new Object[]{new String[]{}});}}";
out.write(String.format(s,N+1,N+1,Q,Q,Q,Q,Q,s,Q,Q,Q,Q,Q));
out.close();
JavaCompiler c=ToolProvider.getSystemJavaCompiler();
c.run(null,null,null,fn);
Class.forName("H"+(N+1)).getMethod("main",a.getClass()).invoke(null,new Object[]{new String[]{}});
}
}
```
It floods the directory with `H*.java` and `H*.class` files. It somehow stops by itself with a huge stack trace after 500 compilations. I don't know how to fix that problem.
Here is what a flooded desktop looks like:
<https://www.dropbox.com/s/iy8ggzps7s55z4e/java2.png?dl=0>
<https://www.dropbox.com/s/jrauw3igjiwrpmd/java1.png?dl=0>
] |
[Question]
[
I, uh....honestly can't believe we don't have this one yet.
# Challenge
Write two functions or programs that:
1. Convert from decimal to percentage
2. Convert from percentage to decimal
You may also write a single program that does both of the above.
# Format
Percentages *must* be taken and returned with a percent sign. (In many languages, this means they will be strings.) They may be integers or floating point numbers.
Decimals are just floating point numbers.
You do not need to handle rounding errors involving very large or very small floating point numbers.
In cases where the numbers are integers (such as 56.0) you may return `56`, `56.`, or `56.0`. (This is intended to make I/O more flexible.)
# Test Cases
```
0.0% <-> 0.0
100.0% <-> 1.0
56.0% <-> 0.56
123.0% <-> 1.23
-11.0% <-> -0.11
-214.91% <-> -2.1491
```
# Scoring
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest answer in each language wins. If you write two separate programs, add their sizes for your score.
[Answer]
# Mathematica, 34+20=54
to Decimal
```
ToExpression@StringDrop[#,-1]/100&
```
to Percentage
```
ToString[100#]<>"%"&
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 7 bytes
From percentage:
```
/L
```
[Test it online!](http://ethproductions.github.io/japt/?v=1.4.5&code=L0w=&input=LTIxNC45MSU=)
To percentage:
```
*L+'%
```
[Test it online!](http://ethproductions.github.io/japt/?v=1.4.5&code=KkwrJyU=&input=LTIuMTQ5MQ==)
[Answer]
# [Python 2](https://docs.python.org/2/), 59 bytes
This one does both.
```
lambda s:'%'in s and`float(s[:-1])/100`or`float(s)*100`+'%'
```
[Try it online!](https://tio.run/##TY/dDoIwDIXv9xS9IQOVufKXQMKTIAkzSFyCG2G78ennxAjrVb/2nJN2edunVpmb2pubxes@CjANjahUYECocZhmLWxsuibFPrki54Ne/8Pk9OWzlzv7MNZACx0BX5QzHtHLr/eagMoqXGV5QCliSBkWrMadfchuO1rOyuoYZ/nu5gzxiGJY1EhJT8ikV5Dg39subjbBskplYYpl4j4 "Python 2 – Try It Online")
# Single functions, score 27 + 28 = 55
## Decimal to percent, 27 bytes
```
lambda s:`float(s)*100`+'%'
```
[Try it online!](https://tio.run/##K6gsycjPM/qfZhvzPycxNyklUaHYKiEtJz@xRKNYU8vQwCBBW11V/X9JanFJsYKtQjSXAhCoG@gZqOtAmIYIpoGeqRlC2MgYxtY10DM0hHOM9AxNLA3VuWK5uNLyixQyFTLzFMDGW4EVFBRl5pUopGlkav4HAA "Python 2 – Try It Online")
## Percent to decimal, 28 bytes
```
lambda s:`float(s[:-1])/100`
```
[Try it online!](https://tio.run/##K6gsycjPM/qfZhvzPycxNyklUaHYKiEtJz@xRKM42krXMFZT39DAIOF/SWpxSbGCrUI0lwIQqBvoGaiq60DYQHkknqkZspSRMRJP19AQmWdkaKJnaaiqzhXLxZWWX6SQqZCZpwC2xwqsoqAoM69EIU0jU/M/AA "Python 2 – Try It Online")
[Answer]
# Java, 45 bytes
-4 bytes thanks to musicman523.
From decimal, to percent:
```
a->new Float(a.split("%")[0])/100
```
To percent, from decimal:
```
a->a*100+"%"
```
[Answer]
# [Perl 6](http://perl6.org/), 10 + 10 = 20 bytes
Decimal to percentage:
```
*×100~'%'
```
Percentage to decimal:
```
*.chop/100
```
[Answer]
# Dyalog APL, 20 bytes
To percentages
```
'%',⍨100∘×
```
From percentages
```
.01×∘⍎¯1↓⊢
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNzkksLs5M/v8/7VHbBHVVdZ1HvSsMDQwedcw4PJ0rHSimZ2B4eDqQ@6i379B6w0dtkx91LQKqVjDQMzbhSldQNzVVVQcA)
[Answer]
# [PHP](https://php.net/), ~~62 bytes~~ 61 bytes
Thanks @ckjbgames
```
$i=readline();echo strstr($i,'%')?(float)$i/100:($i*100).'%';
```
[Try it online!](https://tio.run/##K8go@G9jXwAkVTJti1ITU3Iy81I1NK1TkzPyFYpLioBIQyVTR11VXdNeIy0nP7FEUyVT39DAwAoorAWkNfWActb//@saGuoZqAIA "PHP – Try It Online")
[Answer]
# Haskell 16+19 = 35 bytes
Percent to decimal:
```
(/100).read.init
```
Decimal to percent:
```
(++"%").show.(*100)
```
[Answer]
# JavaScript (ES6), 20+12=32 bytes
## To Decimal
```
p=>parseFloat(p)/100
```
## To Percentage
```
d=>d*100+'%'
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 8 bytes
From % to decimal
```
¨т/
```
[Try it online!](https://tio.run/##MzBNTDJM/f//0IqLTfr//@saGZroWRqqAgA "05AB1E – Try It Online")
And from decimal to %
```
т*'%«
```
[Try it online!](https://tio.run/##MzBNTDJM/f//YpOWuuqh1f//6xrpGZpYGgIA "05AB1E – Try It Online")
### Explanations
```
¨т/
¨ # Cut of last character
т/ # Divide by 100 (I know. Very creative)
т*'%«
т* # Multiply by 100
'%« # Append '%'
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 5 + 5 = 10 bytes
% → number
```
ṖV÷ȷ2
```
[Try it online!](https://tio.run/##y0rNyan8///hzmlhh7ef2G70//9/UwMDPQNVAA "Jelly – Try It Online")
number → %
```
×ȷ2”%
```
[Try it online!](https://tio.run/##y0rNyan8///w9BPbjR41zFX9//@/qZ4BAA "Jelly – Try It Online")
Full program only.
[Answer]
# Excel, 15 + 4 = 19 bytes
Assuming that the values to be converted are stored in field A1
**Percentage to decimal**
```
=NUMBERVALUE(A1)
```
**Decimal to percentage**
```
=A1%
```
[Answer]
# Python 3, ~~81~~ ~~77~~ 74 bytes
```
def a(m):e=m.strip("%");f=float(e);return f/100if e!=m else str(f*100)+"%"
```
[Try it online!](https://tio.run/##VctBCsIwEIXhvaeIgcKMYpxQRGjJYQLOYKBJQxoXPX2MK@nyffwv7/W9prG1F4vyEHFiF81WS8igB42zOFlWX4FxLlw/JSm5W6Igis8uKl42Vj0HuXTFa/@0XEKq4EFbQxrx9N9EwwFuZJ6Po9jxl7Qv)
EDIT: Saved 4 bytes by removing some whitespace.
EDIT: Saved another 3 bytes by setting float(e) to a variable.
[Answer]
# Python 3, ~~26~~ ~~24~~ 23 bytes + 27 bytes = 50 bytes
First program (% -> decimal)
```
float(input()[:-1])*.01
```
Second program (decimal -> %):
```
str(float(input())*100)+'%'
```
Rather similar to the other one. Pretty easy, too.
[Answer]
# [Python 2](https://docs.python.org/2/), 67 bytes
```
lambda x:`float(x.strip('%'))*[100,.01]['%'in x]`+['%','']['%'in x]
```
[Try it online!](https://tio.run/##RYvNCgIhFEb3PcVFELVMvP0QDPQkJowRkjCjYi7s6c1ZtTrnO/Dlb32neOr@/uiLW58vB22a/ZJc5U19agmZM8qE2BvUWiqN1owdIjQ7HzaVjP1T96lAgOGGoMILkWTc6MBRq9t1I54psdMOcgmxgudB9B8 "Python 2 – Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), 71 bytes
```
i=input()
print(float(i[:-1])/100if'%'in i else'%.2f%%'%(float(i)*100))
```
[Try it online!](https://tio.run/##K6gsycjPM/7/P9M2M6@gtERDk6ugKDOvRCMtJz@xRCMz2krXMFZT39DAIDNNXVU9M08hUyE1pzhVXVXPKE1VVV0VplBTC6hGU/P/f10jPUMTS0MA "Python 3 – Try It Online")
[Answer]
# [Retina](https://github.com/m-ender/retina), 77 bytes
```
^-?
$&00
\b%?$
00%$&
\.(..)
$1.
(....)\.(.*)%%
.$1$2
^(-?)0+\B|\B0+(%?)$
$1$2
```
[Try it online!](https://tio.run/##Jck7CsMwEIThfs6hNVKMlh35Aa4EbnIJYZJAijQpQkrfXZHjZvn2n8/z@3rfq/jrrW4xw3VmKA/JDmbiOhT1qgGOiobGI1yCCNTRJWw@5mB9WfeyWu8lB4djqNXUBO2A9icbp/mM0wym4axpQCQPR1MSMXHUhe1NynHhDw "Retina – Try It Online") Link includes test cases. Requires and returns input with at least one digit before and after the decimal point. Explanation: The first stage inserts two leading zeros after any sign, while the second stage inserts two trailing zeros and a `%` sign before any `%` sign. (The `\b` is needed to stop the pattern matching twice for percentages.) The third stage then multiplies by 100. This results in the correct numerical value for floats converted into percentages, but percentages are now 10,000 times too big and now have a duplicated `%` sign, so the fourth stage corrects this. The final stage then trims leading and/or trailing zeros as necessary.
[Answer]
# ES6, 34 bytes
```
n=>1/n?n*100+'%':n.slice(0,-1)/100
```
(Now works with `0.0` and `0%`)
[Try it online!](https://jsfiddle.net/2ndAttmt/x8urh9yt/3/)
This works because `1/n` is `NaN` if a "%" is present and `NaN` is like `false`.
(`1/n` with `n = 0` is `Infinity` (not `NaN`) and `Infinity` is not considered `false` by JS)
[Answer]
# perl 5: 24 bytes
**From % to decimal: 8 bytes** (7 + 1 for p flag)
```
$_/=100
```
*Usage:*
```
echo '-214.91%' | perl -pe '$_/=100'
```
*Output:*
```
-2.1491
```
**From decimal to %: 16 bytes** (15 + 1 for p flag)
```
$_*=100;$_.="%"
```
*Usage:*
```
echo -2.1491 | perl -pe '$_*=100;$_.="%"'
```
*Output:*
```
-214.91%
```
[Answer]
# **Haskell, ~~60~~ 42 bytes**
Decimal to percentage (21 bytes)
```
f x = show(x*100)++"%"
```
Percentage to decimal (21 bytes)
```
f x = read(init x)/100
```
[Answer]
# [,,,](https://github.com/totallyhuman/commata), score 19
## Percent to decimal, 10 [bytes](https://github.com/totallyhuman/commata/wiki/Code_page)
```
-1⇆⊣f100⇆÷
```
### Explanation
Take 56.0% for example.
```
-1⇆⊣f100⇆÷
implicit input ["56.0%"]
-1 push -1 ["56.0%", -1]
⇆ switch "56.0%" and -1 [-1, "56.0%"]
⊣ pop -1 and "56.0%" and push "56.0" ["56.0"]
f pop "56.0" and push 56.0 (convert to float) [56.0]
100 push 100 [56.0, 100]
⇆ switch 56.0 and 100 [100, 56.0]
÷ pop 100 and 56.0 and push 56.0 / 100 [0.56]
implicit output []
```
## Decimal to percent, 9 [bytes](https://github.com/totallyhuman/commata/wiki/Code_page)
```
100×s'%⇆+
```
### Explanation
Take 0.56 for example.
```
100×s'%⇆+
implicitly take input and convert to float [0.56]
100 push 100 [0.56, 100]
× pop 0.56 and 100 and push 100 * 0.56 [56.0]
s pop 56.0 and push "56.0" (convert to string) ["56.0"]
'% push "%" ["56.0", "%"]
⇆ switch "56.0" and "%" ["%", "56.0"]
+ pop "%" and "56.0" and push "56.0%" ["56.0%"]
implicit output []
```
] |
[Question]
[
The goal is to write a program that returns number of 1 bits in a given number.
## Examples
```
5 -> 2
1254 -> 6
56465 -> 8
```
## Winner
The winning submission is the code which runs in the minimum time. You can assume that normal int value in your language can handle any number (no matter how large) and computes all the valid operators defined for integer in O(1).
If two pieces of code run in the same time the winner is the one implemented in fewer bytes.
Please provide some explanation how your code is computing the result.
[Answer]
## C/C++
```
int popcnt(int n)
{
return __builtin_popcount(n);
}
```
For some CPUs `__builtin_popcount` compiles to a single instruction (e.g. `POPCNT` on x86).
Note: requires gcc or gcc-compatible compiler (e.g. ICC).
[Answer]
Using an 8-bit lookup table in the python shell
```
>>> tab=[0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8]
>>> N=123456789
>>> tab[N>>24]+tab[N>>16&255]+tab[N>>8&255]+tab[N&255]
16
```
[Answer]
### Haskell, 9 (+16)
There was a `popCount` routine added to the `Data.Bits` module for GHC v7.2.1/v7.4.1 this summer (see tickets concerning the [primop](http://hackage.haskell.org/trac/ghc/ticket/5413) and [binding](http://hackage.haskell.org/trac/ghc/ticket/5431)).
```
import Data.Bits
popCount
```
There is a good [arbitrary precision popcount function](http://www.dalkescientific.com/writings/diary/archive/2008/07/03/hakmem_and_other_popcounts.html) in the GNU Multiple Precision Arithmetic Library (GMP), which GHC [uses by default](http://hackage.haskell.org/trac/ghc/wiki/ReplacingGMPNotes), but most other serious languages offer bindings to :
### Python, 16 (+12)
```
import gmpy;
gmpy.popcount(...);
```
### Perl, 11 (+22)
```
use GMP::Mpz qw(:all);
popcount(...);
```
[Answer]
fastest for 32 bit numbers:
```
int bitcount(int i){
i=i&0x55555555 + (i>>1)&0x55555555;
i=i&0x33333333 + (i>>2)&0x33333333;
i=i&0x0f0f0f0f + (i>>4)&0x0f0f0f0f;
i=i&0x00ff00ff + (i>>8)&0x00ff00ff;
return i&0x0000ffff + (i>>16)&0x0000ffff;
}
```
for 64 bits:
```
int bitcount(long i){
i=i&0x5555555555555555 + (i>>1)&0x5555555555555555;
i=i&0x3333333333333333 + (i>>2)&0x3333333333333333;
i=i&0x0f0f0f0f0f0f0f0f + (i>>4)&0x0f0f0f0f0f0f0f0f;
i=i&0x00ff00ff00ff00ff + (i>>8)&0x00ff00ff00ff00ff;
i=i&0x0000ffff0000ffff + (i>>16)&0x0000ffff0000ffff;
return i&0x00000000ffffffff + (i>>32)&0x00000000ffffffff;
}
```
these are all for C-based languages that define the binary operators (C, C++, C#, D, java, ...) (barring the `int` `long` type, translate as needed)
for arbitrary bit sizes:
```
int bitcount(BigInt i){
int c=0;
BigInt _2_pow_64 = BigInt(2).pow(64);
while(i>0){
long rem = i.mod(_2_pow_64);//or AND with 0xffffffffffffffff
c+=bitcount(rem);//as defined above
i=i.div(_2_pow_64);//or rshift with 64
}
return c;
}
```
BigInt being the class for integers of arbitrary size, and the `.div`, `.pow`, `.mod` being the 'divide by', 'to the power of' and 'remainder of' functions reps.
[Answer]
### scala:
```
@tailrec
def bits (i: Long, sofar: Int): Int = if (i==0) sofar else bits (i >> 1, (1 & i).toInt + sofar)
```
computes on a 2Ghz single core for about 1.500.000 64bit Long values the number of bits set.
A straight forward recursive method, comparing the last bit, and shifting the number towards zero. The `@tailrec` is just a hint to the compiler to warn me, if it can't optimize the tail recursive call - it is not necessary, for the optimization to take place.
It's about 10times faster than the simplest method, using the library function:
```
def f(n:Long)=n.toBinaryString.count(_=='1')
```
Translating them to c++ might not lead to similar results.
[Answer]
Here is rachet freak's submission (the 32-bit version) converted to Scala (thanks RF!):
```
def num1Bits(x: Int) = {
var i = x
i = (i & 0x55555555) + ((i>> 1) & 0x55555555)
i = (i & 0x33333333) + ((i>> 2) & 0x33333333)
i = (i & 0x0f0f0f0f) + ((i>> 4) & 0x0f0f0f0f)
i = (i & 0x00ff00ff) + ((i>> 8) & 0x00ff00ff)
(i & 0x0000ffff) + ((i>>16) & 0x0000ffff)
}
```
[Answer]
### Erlang
```
p(N)->p(N,0).
p(0,S)->S;p(N,S)->p(N div 2, S+N rem 2).
```
The `p` function divides the number with 2, adds the remainder to S, and calls itself with N/2 (tail) recursively.
While it takes log2(N) steps (division and function call) to calculate the result, it works with arbitrary large numbers.
[Answer]
# C, 33 bytes
I just saw the challenge today, but thought of a recursive solution.
```
B(n){return (n&1)+(n?B(n/2):0);};
```
Edited to note that I assumed it was a smallest size challenge. The speed is linear to the number of bits required to contain the number. O(N) = k \* Log2(N).
[Answer]
# Python (72 bytes)
```
x=bin(int(input()));n=0
for i in x:
if i=='1':
n+=1
print(n)
```
Converts `str`, to `int`, to `bin`, then iterates over the string to count.
[Answer]
# Mathematica
**Mathematica has its built-in function `DigitCount`.**
[Try it online!](https://tio.run/##PcuxCsIwEIDh3afIqCDkksslOaWD6OLm4CZFooQasGlp0@ePCOLwTx9/H8or9qGkZ6h1HMbjsORyy/dzLrGLUyt2jTilLpUfbIXeCtXuV@uQ5@Y/KEWONXjW6FBZxWQ0kgP2BOCtdwzOE2rL7I21ZA18QzbkyBsAxwqVZovMSO1GysNjHt5LidfUp9xJeZlSLrV@AA)
```
popCount[n_Integer] := DigitCount[n, 2, 1];
(ans=popCount[115792089237316195423570985008687907853269984665640564039457584007913129639935])//AbsoluteTiming//Print
```
[Answer]
# Rust
Rust has its **built-in popcount function**:
`(num as u128).count_ones();`
It's also worth noting that \$\color{blue}{\text{this function operates in constant time}}\$. That is, regardless of the input value, it always takes the same amount of time to execute. This is because the number of bits in an integer is fixed, so no matter the value, the same number of bits need to be examined.
### u128
[Try it online!](https://tio.run/##XZFNa8JAEIbv@RWjh5LAGtAakZXQQ6HQS3vpTUS2yUSWrpt0d1YP4l9vOsZEbPc0A8@8H6wLnto2eARPpZSk9yjlq/WkLK2iqLKwV9rGCZwi4GeQwIb9JzoPORywGK0zAdNZNheQLeaLbLO6ccr64x03E7AQsGSgI6raQawFPLBcAtoOsqkmdHGSIu/oFOHNe9DlbI5YtU8ppa2PcbL6wzj0wVygmGVAeQjT2TJJizpY2tYW/f@DMrCXri2fdPopGtV4LC/cDVTeo6Mtfo/iq4EYSq71RsD4RWmDJRB66vqdzmNx6XXn1ThtydhRPH7r@kqGBLxzouv0wR8ApL7Q8i6fegEBg9@Qs5c8R@eobX@KyqidbyfPdUMTgwc0@SNvhuq8UsQTV9ohTYom5JbvD/gL)
```
use std::time::Instant;
fn main() {
let numbers = vec![5, 1254, 56465];
let answers = vec![2, 6, 8];
for (i, &num) in numbers.iter().enumerate() {
let start = Instant::now();
let result = (num as u128).count_ones();
let duration = start.elapsed();
assert_eq!(result, answers[i], "Failed test for {}", num);
println!("Number: {}, Ones: {}, Time taken: {:?}", num, result, duration);
}
}
```
### u256
#### `/src/main.rs`
```
use uint::construct_uint;
use std::time::Instant;
construct_uint! {
pub struct U256(4);
}
fn count_ones(n: U256) -> u32 {
n.as_ref().iter().map(|&b| b.count_ones()).sum()
}
fn main() {
let numbers = vec![
U256::from(5u64),
U256::from(1254u64),
U256::from(56465u64),
U256::from(18446744073709551615u64),
U256::from_dec_str("115792089237316195423570985008687907853269984665640564039457584007913129639935").unwrap(), // 2^256 - 1
];
let answers = vec![2, 6, 8, 64, 256];
for (i, num) in numbers.iter().enumerate() {
let start = Instant::now();
let result = count_ones(num.clone());
let duration = start.elapsed();
assert_eq!(result, answers[i], "Failed test for {}", num);
println!("Number: {}, Ones: {}, Time taken: {:?}", num, result, duration);
}
}
```
#### `Cargo.toml`
```
[package]
name = "rust_hello"
version = "0.1.0"
edition = "2021"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
uint = "0.9"
# bitvec = "1.0.1"
```
#### Build and running
```
# win10 environment
$ cargo build
$ target\debug\rust_hello.exe
Number: 5, Ones: 2, Time taken: 600ns
Number: 1254, Ones: 6, Time taken: 700ns
Number: 56465, Ones: 8, Time taken: 400ns
Number: 18446744073709551615, Ones: 64, Time taken: 700ns
Number: 115792089237316195423570985008687907853269984665640564039457584007913129639935, Ones: 256, Time taken: 800ns
```
] |
[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/28728/edit).
Closed 7 years ago.
[Improve this question](/posts/28728/edit)
Once you [grok vi](https://stackoverflow.com/a/1220118), your muscle memory learns tricks like `ggVGx` to delete all the text in a file. Trouble is, `ggVGx` is not an English word, so it makes a terrible mnemonic.
This challenge is about constructing a single Vi[m] command that can be reasonably read as an English word, phrase or sentence. One point per letter.
Modifier keys such as `meta`/`alt`, `control`, and `shift` should be written as they are in VimScript, e.g. `<C-c>` so we can read them, but will be pronounced as two consecutive letters: `cc`, for a score of 2.
Vim commands that start with `:` are only count toward your scrore if they build a word out of non-words. So `:%s/aword/anotherword/gi` would only add 3 to your score, for `sgi` (and only then if `sgi` is part of an actual English word or phrase, such as `hasgills`. Similarly `:help` would add zero to your score.
No user-defined mappings. Your answer should work on a fresh install of Vim with no .vimrc or other gizmos.
Finally, the command has to do something other than throw an error.
Example Entry:
# cap (3)
`cap`, change a paragraph
[Answer]
Score 60
`:s/foo/bar/incerepellingliceingreeceIgrillripeninggreenpepperinniceice`
>
> since repelling lice in Greece I grill ripening green pepper in nice ice
>
>
>
You can repeat flags arbitrarily in the `:s` command so this can get as long as you care to come up with a sentence/phrase/word using only the letters c,e,g,i,I,n,p,l,r and starting with an s.
[Answer]
`I think this a really cheesy answer.`
Prints " think this is a really cheesy answer.", score of 36. If you count "anything typed in insert mode" as one point, we can construct arbitrarily long cheesy strings like this:
`I think really cheesy answers are accidents. No really, they're accidents. I mentioned they're accidents, right?`
Where each cc in "accident" is the `<Ctrl-C>` insert mode command. The following i puts us back in insert mode for an additional two characters whenever we write "accident". If we have to end in normal mode, we can finish the paragraph with:
`But I really like soccer!`
Which leaves insert mode, moves to the end of the last word, and replaces the last character with a !.
[Answer]
Vim's text objects provide a variety of three-letter words (of which `cap` is one).
```
grep -E '^[cdv][ai][wspbt]$' /usr/share/dict/words
```
* `cab`
* `cap`
* `cat`
* `caw`
* `cis`
* `cit`
* `dab`
* `dap`
* `das`
* `dat`
* `daw`
* `dib`
* `dip`
* `dis`
* `dit`
* `vas`
* `vat`
* `vaw`
* `vip`
* `vis`
I only found one four letter command that is a word:
* `guib`
I opted not to include insert mode commands such as `a`, `r`, `s` where the remainder of the "word" is just text typed into the document. Otherwise, you would have to accept *any* word starting with one of those letters.
[Answer]
Haven't spent much time, but found at least one 6-letter word which is a valid command: toggle (go to next letter 'o', then jump to beginning of file, then second line and to the end of a first word there). I am sure there could be a lot of other words combined from movement commands.
Found another one. This one at least does something (and is 7 letters): forgery (go to 'o', replace with 'g', go to end of word, replace with 'y').
More words and phrases:
```
Brand new
Entangled<space>
Su<cc>ulents
```
] |
[Question]
[
Write the shortest possible program which takes a numeric input and outputs the result of adding 42 to the input.
```
f(x) -> x + 42
```
There's only one restriction. Your program can only be composed of rod logic characters...
---
The definition for a rod logic character is a one that is composed purely of straight lines. They come from the crazy [Temporally Quaquaversal Virtual Nanomachines](https://yow.eventer.com/yow-2011-1004/temporally-quaquaversal-virtual-nanomachine-by-damian-conway-1028) talk by Damian Conway. To simplify things **The following will be considered the set of all valid rod logic characters.**
`_` `|` `-` `=` `\` `/` `<` `>` `[` `]` `^` `+`
Damian writes a rod logic program in Perl which takes a numeric input and outputs the result of adding 42 in 170 lines. He might be great at quantum mechanics in Perl, but I'm not sure he's played much code golf. The challenge is to improve on that.
Like Damian's example we'll say that you have access to two predefined functions:
* `__` - which prints arguments
* `___` - which reads and returns user input
If these aren't valid function identifiers in your language, you can replace them with other (2 and 3 byte ones)
Shortest program wins.
[Answer]
# Brainfuck, 25
```
,>++++++[<+++++++>-]<.
```
Counting `,` as `___` (input) and `.` as `__` (output).
Works by adding 7 to the input 6 times.
[Answer]
# CJam, ~~22~~ 21 bytes
CJam only supports single-character function (block) names, all of which must be uppercase letters. I've used `A` in place of `___` and counted it as 3 bytes:
```
]_=__+__+++__++_+A+
```
[Test it here.](http://cjam.aditsu.net/#code=%7Bq~%7D%3AA%3B%0A%5D_%3D___%2B_%2B%2B_%2B_%2B%2B_%2BA%2B&input=3)
## Explanation
```
]_= "Make an empty array, duplicate, check for equality, pushing 1.";
__+ "Get two copies and add them, leaving the stack as [1 2].";
__+++ "Make two copies add it all up, yielding 7.";
__++ "Make two copies, add them up, yielding 21.";
_+ "Make a copy add it, yielding 42.";
A+ "Read the input and add it.";
```
CJam automatically prints the stack contents at the end of the program.
[Answer]
# JavaScript, 64+3+2=69
```
+[+[++[++[++[+[]==[]][+[]]][+[]]][+[]]+[++[+[]==[]][+[]]]]][+[]]
```
To test it, write a number followed by the whole program in your browser's console.
I didn't explicitly use input and output functions, but I added 3 and 2 bytes to account for them.
**Explanation:**
```
+[] ➜ 0
0==[] ➜ true
++[true][0] ➜ 2
++[2][0] ➜ 3
++[3][0] ➜ 4
4+[2] ➜ "42"
+["42"] ➜ 42
x+[42][0] ➜ x+42
```
[Answer]
## JavaScript / TypeScript / CoffeeScript, 38 bytes
`_` is a valid identifier in JS.
The question is somewhat unclear but I'm assuming that `___` stores input and `__` stores output.
The newlines are necessary (and counted as 1 byte each) regardless of whether you're running it as JavaScript (for ASI) or CoffeeScript (for compilation to JS).
```
_=[]
___+=++_<<++_<<++_
__=___+_+_+++_
```
### Explanation
```
# assigns empty array to _ which will be coerced to number 0 later
_=[]
# Add 32 to input:
# 0+1 << (0+1)+1 << ((0+1)+1)+1 = 1 << 2 << 3
# = 1 << 2 << 3
# = 4 << 3
# = 32 or 0b00100000
# (Also note that _ = 3 now)
___+=++_<<++_<<++_
# Previous value + 3 + 3 + 4
# Total additions: 32 + 3 + 3 + 4 = 42
__=___+_+_+++_
```
### Demo
This is the best I can try to demonstrate it:
```
function ____(___) {
_ = []
___ += ++_ << ++_ << ++_
__ = ___ + _ + _ + ++_
return __
}
document.getElementById('btn').addEventListener('click', function() {
window.alert(____(+document.getElementById('foo').value));
return false;
});
```
```
<label>
Enter a number:
<input type=number id=foo value=0>
</label>
<button type=button id=btn>Add 42</button>
```
[Answer]
# Pyth, 54 + 3 bytes = 57
```
+vz-+^/+\\\\\\/+++\\\\\\\\\\^/++\\\\\\\\/++\\\\\\\\/\\\\
```
Just to show that it can be done in Pyth. `___` isn't valid in Pyth, so I'm using `vz`.
`/` is the only command which returns a number, when used as `/ <string1> <string2>` to mean `string1.count(string2)`, so we use it excessively to create numbers. The 42 is calculated as `2^4 + 3^3 - 1`.
[Try it online](https://pyth.herokuapp.com/?code=%2BQ-%2B%5E%2F%2B%5C%5C%5C%5C%5C%5C%2F%2B%2B%2B%5C%5C%5C%5C%5C%5C%5C%5C%5C%5C%5E%2F%2B%2B%5C%5C%5C%5C%5C%5C%5C%5C%2F%2B%2B%5C%5C%5C%5C%5C%5C%5C%5C%2F%5C%5C%5C%5C&input=13&debug=0).
[Answer]
# piet - 14
This might count. All of the lines are straight.
[Answer]
## C++
This is a work in progress... how can I replace () with []? Is it possible?
```
#include <iostream>
using namespace std;
#define _____(a) int main(){a return 0;}
#define ___(y) cin>>y;
#define __(x) cout<<x<<endl;
#define ______(z) z+=42;
#define ________(p) int p;
_____(________(_) ___(_) ______(_) __(_) ___(_))
```
] |
Subsets and Splits