Bạn được yêu cầu tạo ra một sân golf 18 lỗ ngẫu nhiên.

Ví dụ đầu ra:

[3 4 3 5 5 4 4 4 5 3 3 4 4 3 4 5 5 4]

Quy tắc:

• Chương trình của bạn phải xuất ra một danh sách các độ dài lỗ cho chính xác 18 lỗ
• Mỗi lỗ phải có chiều dài 3, 4 hoặc 5
• Độ dài lỗ phải thêm tối đa 72 cho toàn bộ khóa học
• Chương trình của bạn phải có khả năng tạo ra mọi cấu hình lỗ có thể với một số xác suất khác không (xác suất của mỗi cấu hình không cần bằng nhau, nhưng hãy thoải mái yêu cầu thêm kudos nếu đây là trường hợp)

k ( 18 17 16 ký tự)

Quay lại cách tiếp cận ban đầu, tín dụng cho CS để cải thiện.

(+/4-){3+18?3}/0

Cách tiếp cận khác (17 ký tự), cùng phương thức với giải pháp J, H / T cho CS

4+a,-a:9?2 -18?18

Phiên bản cũ:

(72-+/){18?3+!3}/0

Không dễ bị tràn chồng và chạy trong một không gian cố định.

K, 28

{$[72=+/s:18?3 4 5;s;.z.s`]}

J, 20 18 17 ký tự

(?~18){4+(,-)?9#2

Điều này hoạt động theo cách tương tự như câu trả lời trước ngoại trừ 9 chữ số ngẫu nhiên là 0 hoặc 1 và bị phủ định trước khi được thêm vào. Điều này có nghĩa là có nhiều -1s như có 1s. Thêm 4 cho tôi một danh sách 3s, 4s và 5s thêm tới 72 mỗi lần.

Câu trả lời trước:

({~?~@#)3+(,2-])?9#3

Tạo ngẫu nhiên 9 lỗ đầu tiên ?9#3, sau đó sao chép và đảo ngược chúng (,2-])(biến 3 thành 5 và 5 thành 3) để tạo ra lỗ cuối cùng 9. Điều này đảm bảo rằng tổng số sẽ là 72 (vì cứ 3 sẽ có 5 khớp tổng trung bình mỗi lỗ sẽ là 4 và 4x18 = 72). Sau đó, nó ngẫu nhiên xáo trộn kết quả ({~?~@#)để đảm bảo rằng mọi sự kết hợp đều có thể.

Mã máy 16 bit x86 trong MS-DOS - 45 byte

Hexdump:

0E5F576A12595188ECE44088C3E44130D8240374F400C4AAE2EF595E80FC2475DFAC0432CD29B020CD29E2F5C3

Mã nhị phân Base64:

Dl9XahJZUYjs5ECIw+RBMNgkA3T0AMSq4u9ZXoD8JHXfrAQyzSmwIM0p4vXD

Mã nguồn thực tế với một số ý kiến:

 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.

Biên dịch với nasm 18h.asm -o 18h.comvà chạy trong MS-DOS (hoặc Dosbox) hoặc NTVDM từ phiên bản Windows 32 bit.

Đầu ra mẫu:

4 5 4 5 4 5 3 4 3 4 3 4 4 5 4 3 5 3

Toán học 71 68 66 60

Với 6 ký tự được lưu bởi đề xuất của Tally.

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}

Tất cả các kết quả có thể là có thể, nhưng chúng không có khả năng như nhau.

Phân tích

IntegerPartitions[72, {18}, {3, 4, 5}]

tạo ra tất cả 10 phân vùng có thể (kết hợp, không hoán vị) của 72 thành 18 phần tử bao gồm 3, 4 và 5.

RandomChoice chọn một trong số đó

RandomSample trả về một hoán vị của sự lựa chọn đó.

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

Thuật toán tương tự như @ sgrieve's.

GolfScript (26 ký tự)

{;0{3rand.3+@@+(}18*])}do`

Có một số điểm tương đồng rõ ràng với giải pháp của Ilmari, nhưng cũng có một số khác biệt rõ ràng. Cụ thể, tôi đang khai thác thực tế là mệnh giá trung bình là 4.

Con trăn 77

Mã

from numpy.random import*;l=[]
while sum(l)!=72:l=randint(3,6,18)
print l

Đầu ra

[3 4 4 5 3 3 3 5 4 4 5 4 5 3 4 4 5 4]

Việc nhập khẩu thực sự giết chết giải pháp này. Nó sử dụng numpy để tạo ra 18 số từ 3 đến 5 và tiếp tục tạo danh sách cho đến khi tổng của danh sách bằng 72.

GolfScript, 27 ký tự

{;18{3.rand+}*].{+}*72-}do`

Sử dụng phương pháp lấy mẫu từ chối tương tự như giải pháp Python của sgrieve. Vì vậy, mọi đầu ra hợp lệ thực sự đều có khả năng như nhau.

Q (25 ký tự)

Bản gốc (27)

while[72<>sum a:18?3 4 5];a

Sản lượng mẫu

4 4 3 3 4 5 4 3 4 5 5 3 5 5 5 4 3 3

Hơi ngắn hơn (25)

{72<>sum x}{x:18?3 4 5}/0

JavaScript, 66 64 61 ký tự

Lấy cảm hứng mạnh mẽ từ TwoScoopsofPig (PHP) và 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

Python 2, 70 byte

from random import*
print sample(([3,5]*randint(0,9)+[4]*99)[:18],18)

Đây là một giải pháp khác, tương tự như giải pháp của sgrieve:

Python 2, 73 byte + xác suất bằng nhau

from random import*
a=[]
while sum(a)-72:a=sample([3,4,5]*18,18)
print a

JavaScript, 116 99 65 byte

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

Con trăn, 128 120 116 ký tự

import random,itertools
random.choice([g for g in itertools.product(*(range(3,6)for l in range(18))) if sum(g)==72])

import câu lệnh vẫn là kẻ giết chiều dài (chỉ 23 ký tự để nhập 2 hàm trong không gian tên)

Tôi hy vọng bạn không cần kết quả trong tương lai gần, vì mã này trước tiên đánh giá tất cả các giải pháp có thể trước khi chọn một giải pháp ngẫu nhiên. có lẽ là giải pháp chậm nhất cho vấn đề này

tôi yêu cầu thêm kudos cho xác suất tương đương của mỗi cấu hình ...

PHP - 77 ký tự

<?while(array_sum($a)!=72){for($i=0;18>$i;){$a[++$i]=rand(3,5);}}print_r($a);

Giống như giải pháp của sgrieve, cái này xây dựng một danh sách 18 lỗ, kiểm tra tổng mệnh giá, và in nó hoặc từ chối nó và thử lại. Thật kỳ lạ, hai giải pháp của chúng tôi có cùng chiều dài.

Khá khó chịu, PHP không cung cấp các hàm mảng với bất kỳ tên ngắn gọn nào. Array_sum và print_r đang giết tôi. Gợi ý chào mừng.

Ruby 1.9 (62 ký tự)

a=Array.new(18){[3,4,5].sample}until(a||[]).inject(:+)==72
p a

Đường ray (55 ký tự)

Trong $ rails cREPL (trong bất kỳ thư mục Rails):

a=Array.new(18){[3,4,5].sample}until(a||[]).sum==72
p a

Lưu ý: Nó hoạt động với Ruby 1.8 nếu bạn sử dụng shuffle[0]thay vì sample.

Lisp ( 78 69 ký tự)

(do ((c () (mapcar (lambda (x) (+ 3 (ngẫu nhiên 3))) (danh sách 18)))) ((= (áp dụng '+ c) 72) c))

(do((c()(loop repeat 18 collect(+ 3(random 3)))))((=(apply'+ c)72)c))

Nó khá giống với giải pháp Python của sgrieve.

Bắt đầu với c là NIL, kiểm tra tổng 72, do"hàm tăng" cho c tạo danh sách 18 số từ 3 đến 5, kiểm tra lại 72, rửa, rửa, lặp lại.

Thật sảng khoái khi thấy dovà loopchơi golf cùng nhau.

C (123 ký tự) - nỗ lực về hiệu quả

Chuyển qua wc và nó sẽ tạo ra tất cả 44152809 giải pháp trong vòng 10 giây ...

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);}

Ồ, tốt - đã không đọc đúng câu hỏi - nhưng được cho là chúng tôi tạo ra tất cả các giải pháp sau đó chọn một câu hỏi ngẫu nhiên có xác suất bằng nhau là một bài tập kịch bản: P

Clojure - 55

(shuffle(mapcat #([[4 4][3 5]%](rand-int 2))(range 9)))

Một mẹo khá thú vị .... khai thác cấu trúc toán học của bài toán rằng phải có chính xác nhiều lỗ 3 par bằng 5 lỗ par.

Con trăn 83

import random as r;x=[]
while sum(x)!=72:x=[r.randint(3,5) for i in 18*[0]]
print x

Giống như giải pháp sgrease, nhưng không có numpy

Giải pháp chơi gôn của Adrien Plisson: 120-> 108 ký tự

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

Đầu ra :

x = 4 3 4 4 4 4 5 4 4 3 4 4 3 5 3 5 4 5

Java (61 ký tự)

while(s!=72)for(i=0,s=0;i<18;i++)s+=3+(int)(Math.random()*3);

Đầu ra mẫu:

5 4 3 4 5 3 4 4 3 5 4 4 4 4 3 4 4 5

C (94 ký tự)

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]);

Các s=0trên dòng 1 có thể không được yêu cầu, bởi vì rất có thể là những gì một int chưa được khởi tạo sẽ bằng 72? Tôi chỉ không thích đọc các giá trị chưa được khởi tạo trong thẳng C. Ngoài ra, điều này có thể yêu cầu gieo mầm rand()hàm.

đầu ra

3 3 3 4 5 5 3 3 4 5 5 4 3 4 5 5 5 3 

Kịch bản shell Bash (65 ký tự)

shuf -e `for x in {0..8}
do echo $((r=RANDOM%3+3)) $((8-r))
done`

( shuf đến từ gói GNU coreutils. Ngoài ra, cảm ơn Gareth.)

C # (143 không phải khoảng trắng):

()=>{
  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);
}

Haskell, 104 102 98 ký tự.

import System.Random
q l|sum l==72=print l|1>0=main
main=mapM(\_->randomRIO(3::Int,5))[1..18]>>=q

Perl, 74

{@c=map{3+int rand 3}(0)x18;$s=0;$s+=$_ for@c;redo unless$s==72}print"@c"

Giải pháp thay thế:

@q=((3,5)x($a=int rand 9),(4,4)x(9-$a));%t=map{(rand,$_)}(0..17);print"@q[@t{sort keys%t}]"

TXR (99 ký tự)

@(bind g@(for((x(gen t(+ 3(rand 3))))y)(t)((pop x))(set y[x 0..18])(if(= [apply + y]72)(return y))))

Biểu thức này tạo ra một danh sách lười biếng vô hạn các số ngẫu nhiên từ 3 đến 5:

(gen t (+ 3(rand 3)))  ;; t means true: while t is true, generate.

Phần còn lại của logic là một vòng lặp đơn giản để kiểm tra xem 18 phần tử đầu tiên của danh sách này có cộng với 72 hay không. Nếu không, nó sẽ tắt một phần tử và thử lại. Các forvòng lặp chứa một khối tiềm ẩn gọi nilvà do đó (return ...)có thể được sử dụng để chấm dứt vòng lặp và trở về giá trị.

Lưu ý rằng độ dài 99 ký tự bao gồm một dòng mới kết thúc, được yêu cầu.

APL 12

4+{⍵,-⍵}?9⍴2

Lưu ý rằng tôi có gốc chỉ mục được đặt thành 0, nghĩa là các mảng bắt đầu từ 0. Bạn có thể đặt giá trị này bằng ⎕IO←0.

R, 42 byte

a=0;while(sum(a)-72)a=sample(3:5,18,r=T);a

sample, theo mặc định, rút ​​ra đồng đều giữa các giá trị có thể (ở đây 3 4 5). r=Tlà viết tắt của replace=TRUEvà cho phép mẫu với sự thay thế.

CJam, 17 14 byte

CJam mới hơn thử thách này, nhưng dù sao đây cũng không phải là câu trả lời ngắn nhất, vì vậy điều đó không thực sự quan trọng.

Z5]Amr*I4e]mrp

Kiểm tra nó ở đây.

Để duy trì tổng số 72, mỗi cái 3phải được ghép với 5. Vì vậy, đây là cách nó hoạt động:

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.