[Question]
  [
You are required to generate a random 18-hole golf course.
Example output:
```
[3 4 3 5 5 4 4 4 5 3 3 4 4 3 4 5 5 4]
```
Rules:
* Your program must output a list of hole lengths for exactly 18 holes
* Each hole must have a length of 3, 4 or 5
* The hole lengths must add up to 72 for the entire course
* Your program must be able to produce every possible hole configuration with some non-zero-probability (the probabilities of each configuration need not be equal, but feel free to claim extra kudos if this is the case)
  
[Answer]
# k (~~18 17~~ 16 chars)
Back to the original approach, credit to CS for the improvement.
```
(+/4-){3+18?3}/0
```
Other approach (17 chars), same method as the J solution, H/T to CS
```
4+a,-a:9?2 -18?18
```
~~Old version:~~
```
(72-+/){18?3+!3}/0
```
Not susceptible to stack-overflow and runs in fixed amount of space.
[Answer]
# K, 28
```
{$[72=+/s:18?3 4 5;s;.z.s`]}
```
[Answer]
## J, 20 18 17 characters
```
(?~18){4+(,-)?9#2
```
This works in the same way as the previous answer except that the 9 random digits are either 0 or 1 and are negated before being appended. This means there are as many `-1`s as there are `1`s. Adding 4 gives me a list of `3`s, `4`s and `5`s that add up to 72 every time.
Previous answer:
```
({~?~@#)3+(,2-])?9#3
```
Generates the first 9 holes randomly `?9#3`, then copies and inverts them `(,2-])` (turns a 3 into a 5 and a 5 into a 3) to generate the final 9. This guarantees that the total will be 72 (since every 3 will have a matching 5 the average total per hole will be 4 and 4x18=72). It then randomly shuffles the result `({~?~@#)` to ensure that every combination is possible.
[Answer]
## 16-bit x86 machine code under MS-DOS - 45 bytes
Hexdump:
```
0E5F576A12595188ECE44088C3E44130D8240374F400C4AAE2EF595E80FC2475DFAC0432CD29B020CD29E2F5C3
```
Base64 coded binary:
```
Dl9XahJZUYjs5ECIw+RBMNgkA3T0AMSq4u9ZXoD8JHXfrAQyzSmwIM0p4vXD
```
Actual source code with some comments:
```
 bits 16
 org 0x100
again:
 push cs               ; Save whatever CS we get.
 pop di                ; Use CS:DI as our course buffer..
 push di               ; Save for later use in the print loop
 push 18               ; We need 18 holes for our golf course.
 pop cx                ; ch = 0, cl = 18.
 push cx               ; Save for later use.
 mov ah, ch            ; Zero out ah.
generate_course:
 in al, 0x40           ; Port 0x40 is the 8253 PIT Counter 0.
 mov bl, al            ; Save the first "random" value in bl.
 in al, 0x41           ; Port 0x41 is the 8253 PIT Counter 1.
 xor al, bl            ; Add some more pseudo randomness.
 and al, 3             ; We only need the two lower bits.
 jz generate_course    ; If zero, re-generate a value, since we need only 3, 4, 5 holes.
 add ah, al            ; Sum in ah register.
 stosb                 ; Store in the course buffer.
 loop generate_course  ; Loop for 18 holes.
 pop cx                ; cx = 18.
 pop si                ; si = course buffer.
 cmp ah, 36            ; 72 holes?
 jne again             ; No, re-generate the whole course.
print:                 ; Yup, we have a nice course.
 lodsb                 ; Load the next hole.
 add al, '2'           ; Add ASCII '2' to get '3', '4' or '5'
 int 0x29              ; Undocumented MS-DOS print function.
 mov al, ' '           ; Print a space too for better readability.
 int 0x29              ; Print the character.
 loop print            ; Print the whole course.
 ret                   ; Return to the beginning of the PSP where a INT 0x20 happen to be.
```
Compile with `nasm 18h.asm -o 18h.com` and run under MS-DOS (or Dosbox), or NTVDM from a 32-bit Windows version.
Sample output:
```
4 5 4 5 4 5 3 4 3 4 3 4 4 5 4 3 5 3
```
[Answer]
# Mathematica 71 68 66 60
With 6 chars saved by Tally's suggestion.
```
RandomSample@RandomChoice@IntegerPartitions[72, {18}, {3, 4, 5}]
```
> 
> {5, 4, 3, 3, 5, 3, 5, 5, 3, 3, 4, 5, 3, 5, 4, 4, 5, 3}
> 
> 
> 
All possible outcomes are possible, but they are not equally likely.
---
**Analysis**
```
IntegerPartitions[72, {18}, {3, 4, 5}]
```
produces all 10 possible partitions (combinations, not permutations) of 72 into 18 elements consisting of 3's, 4's and 5's.
![partitions](https://i.stack.imgur.com/MpOBI.png)
---
`RandomChoice` selects one of those.
`RandomSample` returns a permutation of that choice.
[Answer]
## R - 41
```
x=0;while(sum(x)!=72)x=sample(3:5,18,T);x
# [1] 5 3 5 3 3 3 3 3 5 4 5 4 5 4 4 5 5 3
```
The algorithm is similar to @sgrieve's.
[Answer]
## GolfScript (26 chars)
```
{;0{3rand.3+@@+(}18*])}do`
```
There are some obvious similarities with Ilmari's solution, but also some obvious differences. In particular, I'm exploiting the fact that the average par is 4.
[Answer]
# JavaScript, ~~66~~ ~~64~~ 61 chars
Heavily inspired by TwoScoopsofPig (PHP) and Joe Tuskan (JS).
```
for(a=[s=0];s!=72;)for(s=i=0;i<18;s+=a[i++]=Math.random()*3+3|0);a
```
```
for(a=[s=0];s-72;)for(s=i=0;i<18;s+=a[i++]=Math.random()*3+3|0)a
```
```
for(a=s=[];s;)for(i=18,s=72;i;s-=a[--i]=Math.random()*3+3|0)a
```
[Answer]
# Python 77
**Code**
```
from numpy.random import*;l=[]
while sum(l)!=72:l=randint(3,6,18)
print l
```
**Output**
```
[3 4 4 5 3 3 3 5 4 4 5 4 5 3 4 4 5 4]
```
The import really kills this solution. It uses numpy to generate a 18 numbers between 3 and 5 and keeps generating lists until the sum of the list equals 72.
[Answer]
## GolfScript, 27 chars
```
{;18{3.rand+}*].{+}*72-}do`
```
Uses the same rejection sampling method as sgrieve's Python solution. Thus, every valid output actually is equally likely.
[Answer]
# Python 2, 70 bytes
```
from random import*
print sample(([3,5]*randint(0,9)+[4]*99)[:18],18)
```
edit:
Here's another one, similar to the solution of sgrieve:
# Python 2, 73 bytes + equal probability
```
from random import*
a=[]
while sum(a)-72:a=sample([3,4,5]*18,18)
print a
```
[Answer]
## Q (25 characters)
Original (27)
```
while[72<>sum a:18?3 4 5];a
```
Sample output
```
4 4 3 3 4 5 4 3 4 5 5 3 5 5 5 4 3 3
```
Slightly shorter (25)
```
{72<>sum x}{x:18?3 4 5}/0
```
[Answer]
**Python, 128 120 116 characters**
```
import random,itertools
random.choice([g for g in itertools.product(*(range(3,6)for l in range(18))) if sum(g)==72])
```
*`import` statements are still length killers (23 characters only to import 2 function in the namespace)*
i hope you do not need the result in a near future, as this code first evaluates all possible solutions before chosing one at random. maybe the slowest solution to this problem.
i do claim extra kudos for equal probability of each configuration...
[Answer]
# PHP - 77 Chars
```
<?while(array_sum($a)!=72){for($i=0;18>$i;){$a[++$i]=rand(3,5);}}print_r($a);
```
Much like sgrieve's solution, this builds a list of 18 holes, checks total par, and either prints it or rejects it and tries again. Oddly enough, our two solutions are the same length.
Rather annoyingly, PHP doesn't offer array functions with any brevity of name. Array\_sum and print\_r are killing me. Suggestions welcome.
[Answer]
# Ruby 1.9 (62 chars)
```
a=Array.new(18){[3,4,5].sample}until(a||[]).inject(:+)==72
p a
```
# Rails (55 chars)
In the `$ rails c` REPL (in any Rails folder):
```
a=Array.new(18){[3,4,5].sample}until(a||[]).sum==72
p a
```
*Note: It works with Ruby 1.8 if you use `shuffle[0]` instead of `sample`.*
[Answer]
# Lisp (~~78~~ 69 chars)
~~(do((c()(mapcar(lambda(x)(+ 3(random 3)))(make-list 18))))((=(apply'+ c)72)c))~~
```
(do((c()(loop repeat 18 collect(+ 3(random 3)))))((=(apply'+ c)72)c))
```
It's rather similar to sgrieve's Python solution.
Start with c as NIL, check for a sum of 72, the `do` "increment function" for c generates a list of 18 numbers between 3 and 5, check for 72 again, lather, rinse, repeat.
It's refreshing to see `do` and `loop` nicely play golf together.
[Answer]
# JavaScript, ~~116~~ ~~99~~ 65 bytes
~~`for(i=0,h=[];i<18;)h[i++]=5;while(h.reduce(function(a,b){return a+b})!=72){i=Math.random()*18|0;h[i]=[3,4,4][i%3]}h;`~~
~~`h=[0];while(h.reduce(function(a,b){return a+b})-72)for(i=0;i<18;h[i++]=[3,4,5][Math.random()*3|0])h`~~
```
while(i%18||(a=[i=s=0]),s+=a[i++]=Math.random()*3+3|0,s-72|i-18)a
```
[Answer]
## C (123 chars) - effort on efficiency
Pipe through wc and it will generate all 44152809 solutions within 10 seconds...
```
char s[19];g(d,t){int i;if(d--){for(i=51,t-=3;i<54;i++,t--)if(t>=3*d&&t<=5*d)s[d]=i,g(d,t);}else puts(s);}main(){g(18,72);}
```
Oh, well - didn't read the question properly - but given we're generating all solutions then picking a random one with equal probability is a scripting exercise :P
[Answer]
# Clojure - 55
```
(shuffle(mapcat #([[4 4][3 5]%](rand-int 2))(range 9)))
```
Quite a fun trick.... exploits the mathematical structure of the problem that there must be exactly as many 3 par holes as 5 par holes.
[Answer]
# Python 83
```
import random as r;x=[]
while sum(x)!=72:x=[r.randint(3,5) for i in 18*[0]]
print x
```
Like sgrieve's solution, but without numpy
**Golfing Adrien Plisson's solution:**
120->108 characters
```
import random as r,itertools as i
r.choice([g for g in i.product(*([3,4,5,6]for l in 18*[0]))if sum(g)==72])
```
# MATLAB 53
```
x=[];
while sum(x)~=72
x=3+floor(rand(1,18)*3);
end
x
```
**Output**:
> 
> x =
>  4 3 4 4 4 4 5 4 4 3 4 4 3 5 3 5 4 5
> 
> 
> 
[Answer]
# Java (61 chars)
```
while(s!=72)for(i=0,s=0;i<18;i++)s+=3+(int)(Math.random()*3);
```
Sample output:
```
5 4 3 4 5 3 4 4 3 5 4 4 4 4 3 4 4 5
```
[Answer]
## CJam, ~~17~~ 14 bytes
CJam is newer than this challenge, but this is not the shortest answer anyway, so that doesn't really matter.
```
Z5]Amr*I4e]mrp
```
[Test it here.](http://cjam.aditsu.net/)
To maintain the total of 72, each `3` must be paired with `5`. So here is how it works:
```
Z5]            e# Push [3 5].
   Amr         e# Get a random number between 0 and 9.
      *        e# Repeat the [3 5] array that many times.
       I4e]    e# Pad the array to size 18 with 4s.
           mr  e# Shuffle the array.
             p e# Print it.
```
[Answer]
# C (94 chars)
```
int h[18],s=0,i;
while(s!=72)for(i=s=0;i<18;s+=h[i++]=rand()%3+3);
while(i)printf("%d ",h[--i]);
```
The `s=0` on line 1 may not be required, because what are the chances an uninitialized int will equal 72? I just don't like reading uninitialized values in straight C. Also, this probably requires seeding the `rand()` function.
## output
```
3 3 3 4 5 5 3 3 4 5 5 4 3 4 5 5 5 3 
```
[Answer]
## Bash shell script (65 chars)
```
shuf -e `for x in {0..8}
do echo $((r=RANDOM%3+3)) $((8-r))
done`
```
([shuf](//www.gnu.org/software/coreutils/manual/html_node/shuf-invocation.html) comes from the GNU coreutils package. Also, thanks Gareth.)
[Answer]
# C# (143 non-whitespace):
```
()=>{
  var n=new Math.Random().Next(10);
  Enumerable.Range(1,18)
    .Select((x,i)=>i<n?3:i>=18-n?5:4)
    .OrderBy(x=>Guid.NewGuid())
    .ForEach(Console.Write);
}
```
[Answer]
# Haskell, 104 102 98 chars.
```
import System.Random
q l|sum l==72=print l|1>0=main
main=mapM(\_->randomRIO(3::Int,5))[1..18]>>=q
```
[Answer]
## Perl, 74
```
{@c=map{3+int rand 3}(0)x18;$s=0;$s+=$_ for@c;redo unless$s==72}print"@c"
```
Alternative solution:
```
@q=((3,5)x($a=int rand 9),(4,4)x(9-$a));%t=map{(rand,$_)}(0..17);print"@q[@t{sort keys%t}]"
```
[Answer]
## VBA - 117
VBA never wins at golf. :-)
```
Sub a()
Do Until d=72
d=0
c=""
For b=1 To 18
e=Int(3*Rnd()+3)
c=c &" " &e
d=d+e
Next
Loop
MsgBox c
End Sub
```
[Answer]
# TXR (99 chars)
```
@(bind g@(for((x(gen t(+ 3(rand 3))))y)(t)((pop x))(set y[x 0..18])(if(= [apply + y]72)(return y))))
```
This expression generates an infinite lazy list of random numbers from 3 to 5:
```
(gen t (+ 3(rand 3)))  ;; t means true: while t is true, generate.
```
The rest of the logic is a simple loop which checks whether the first 18 elements of this list add up to 72. If not, it pops an element off and tries again. The `for` loop contains an implicit block called `nil` and so `(return ...)` can be used to terminate the loop and return value.
Note that the 99 character length includes a terminating newline, which is required.
[Answer]
## APL 12
```
4+{⍵,-⍵}?9⍴2
```
Note that I have the index origin set to 0, meaning arrays start at 0. You can set this with `⎕IO←0`.
]