Вам потрібно створити випадкове поле для гольфу на 18 лунок.

Приклад виводу:

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

Правила:

• Ваша програма повинна вивести список довжин отворів рівно на 18 отворів
• Кожен отвір повинен мати довжину 3, 4 або 5
• Довжина отворів повинна складати до 72 за весь курс
• Ваша програма повинна бути здатна виробляти всі можливі конфігурації отворів з деякою ненульовою ймовірністю (ймовірності кожної конфігурації не повинні бути рівними, але сміливо вимагайте додаткових кудо, якщо це так)

k ( 18 17 16 символів)

Повернувшись до оригінального підходу, кредитуйте CS на покращення.

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

Інший підхід (17 символів), той самий метод, що і J-рішення, H / T до CS

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

Стара версія:

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

Не сприйнятливий до переповнення стека та працює у фіксованій кількості простору.

К, 28

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

J, 20 18 17 символів

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

Це працює так само, як і в попередній відповіді, за винятком того, що 9 випадкових цифр або 0, або 1 і заперечуються перед додаванням. Це означає, що існує стільки -1s, скільки є 1s. Додавання 4 дає мені список 3s, 4s та 5s, що додають до 72 кожного разу.

Попередня відповідь:

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

Створює перші 9 отворів випадковим чином ?9#3, потім копіює та інвертує їх (,2-])(перетворює 3 у 5 та 5 на 3), щоб генерувати остаточне 9. Це гарантує, що загальна сума буде 72 (оскільки кожен 3 матиме відповідність 5 середня загальна сума на один отвір складе 4, а 4х18 = 72). Потім він випадковим чином переміщує результат, ({~?~@#)щоб переконатися, що можлива кожна комбінація.

16-розрядний машинний код x86 під MS-DOS - 45 байт

Hexdump:

0E5F576A12595188ECE44088C3E44130D8240374F400C4AAE2EF595E80FC2475DFAC0432CD29B020CD29E2F5C3

Кодований двійковий код Base64:

Dl9XahJZUYjs5ECIw+RBMNgkA3T0AMSq4u9ZXoD8JHXfrAQyzSmwIM0p4vXD

Фактичний вихідний код із коментарями:

 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.

Компілюйте nasm 18h.asm -o 18h.comта працюйте під MS-DOS (або Dosbox) або NTVDM з 32-розрядної версії Windows.

Вибірка зразка:

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

Математика 71 68 66 60

6 пропозицій збережено за пропозицією Таллі.

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}

Всі можливі результати можливі, але вони не однаково вірогідні.

Аналіз

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

створює всі 10 можливих розділів (комбінацій, а не перестановок) з 72 на 18 елементів, що складаються з 3-х, 4-х та 5-х.

RandomChoice вибирає один із них.

RandomSample повертає перестановку за цим вибором.

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

Алгоритм схожий на @ sgrieve's.

GolfScript (26 символів)

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

Є кілька очевидних подібностей з рішенням Ільмарі, але також і деякі очевидні відмінності. Зокрема, я використовую той факт, що середній показник - 4.

Пітон 77

Код

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

Вихід

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

Імпорт дійсно вбиває це рішення. Він використовує numpy, щоб генерувати 18 чисел між 3 і 5 і зберігає генерувати списки, поки сума списку не дорівнює 72.

GolfScript, 27 символів

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

Використовується той самий метод вибірки відхилення, що і рішення Pyghon sgrieve. Таким чином, кожен дійсний результат насправді є однаково вірогідним.

Q (25 символів)

Оригінал (27)

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

Вибірка зразка

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

Трохи коротше (25)

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

JavaScript, 66 64 61 символів

Дуже натхненний TwoScoopsofPig (PHP) та Джо Тускан (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 байт

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

Ось ще одна, схожа на рішення sgrieve:

Python 2, 73 байти + однакова ймовірність

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

JavaScript, 116 99 65 байт

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

Пітон, 128 120 116 символів

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

import заяви все ще вбивці довжини (23 символи лише для імпортування 2 функції в область імен)

Я сподіваюсь, що результат вам не знадобиться найближчим часом, оскільки цей код спочатку оцінює всі можливі рішення, перш ніж вибір навмання. можливо, найповільніше вирішення цієї проблеми.

я вимагаю зайвих кудосів для однакової ймовірності кожної конфігурації ...

PHP - 77 символів

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

Так само, як рішення sgrieve, це створює список з 18 дірок, перевіряє загальну номінальну кількість, або друкує його, або відкидає його і повторює спробу. Як не дивно, але наші два рішення однакової довжини.

Швидше прикро, PHP не пропонує функції масиву з якоюсь стислістю імен. Array_sum і print_r вбивають мене. Пропозиції вітаються.

Рубін 1,9 (62 символи)

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

Рейки (55 символів)

У $ rails cREPL (у будь-якій папці Rails):

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

Примітка. Це працює з Ruby 1.8, якщо ви використовуєте shuffle[0]замість цього sample.

Лісп ( 78 69 символів)

(do ((c () (mapcar (лямбда (x) (+ 3 (випадковий 3))) (make-list 18)))) ((= (застосувати '+ c) 72) c))

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

Він досить схожий на рішення Pyghon sgrieve.

Почніть з c як NIL, перевірте суму 72, do"функція приросту" для c генерує список з 18 чисел між 3 і 5, ще раз перевірте на 72, мийте, промийте, повторіть.

Це освіжаюче бачити doі loopгарно грати в гольф разом.

C (123 знаків) - зусилля щодо ефективності

Трубопровід через туалет, і він генерує всі 44152809 рішення протягом 10 секунд ...

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

О, добре - не прочитав питання належним чином - але, враховуючи, що ми генеруємо всі рішення, то вибір випадкового з однаковою ймовірністю - це сценарій вправ: P

Clojure - 55

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

Досить цікавий трюк .... експлуатує математичну структуру проблеми, що повинно бути рівно стільки 3 отворів, скільки 5 норів.

Пітон 83

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

Як рішення sgrieve, але без нумету

Рішення для гольфінгу Адрієна Пліссона: 120-> 108 символів

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

Вихід :

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

Java (61 символів)

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

Вибірка зразка:

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

C (94 знаків)

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

s=0На лінії 1 може не знадобитися, оскільки які шанси неініціалізованих ІНТ буде дорівнює 72? Мені просто не подобається читати неініціалізовані значення прямо в C. Також це, мабуть, вимагає висівання rand()функції.

вихід

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

Сценарій Bash shell (65 символів)

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

( shuf походить від пакета coreutils GNU. Також, дякую Гарет.)

C # (143 пробіли):

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

Хаскелл, 104 102 98 символів.

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

Перл, 74

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

Альтернативне рішення:

@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 знаків)

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

Цей вираз породжує нескінченний лінивий список випадкових чисел від 3 до 5:

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

Інша логіка - це простий цикл, який перевіряє, чи досягає перших 18 елементів цього списку до 72. Якщо ні, він спливає елемент і намагається знову. forЦикл містить неявний блок , званий nilі так (return ...)може бути використаний для завершення циклу і повернення значення.

Зауважте, що довжина 99 символів включає завершальний новий рядок, який необхідний.

12 APL

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

Зауважте, що у мене початкове значення індексу встановлено на 0, тобто масиви починаються з 0. Ви можете встановити це за допомогою ⎕IO←0.

R, 42 байти

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

sample, за замовчуванням, рівномірно малює серед можливих значень (тут 3 4 5). r=Tрозшифровує replace=TRUEта дозволяє зразок із заміною.

CJam, 17 14 байт

CJam є новішим, ніж ця проблема, але це все одно не найкоротша відповідь, так що насправді це не має значення.

Z5]Amr*I4e]mrp

Перевірте це тут.

Щоб зберегти загальну кількість 72, кожен 3повинен бути сполучений з 5. Отже, ось як це працює:

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.