Biaya pembelian titik D&D

20

Saat membuat karakter Dungeons & Dragons , alternatif untuk skor kemampuan bergulir adalah dengan menetapkannya dalam anggaran daya yang disebut point buy. Skor kemampuan yang lebih tinggi membutuhkan lebih banyak poin, terutama ke arah ujung atas: skor 8 adalah gratis, dan menaikkan skor dengan 1 biaya 1 poin, kecuali naik ke 15 atau 16 biaya 2 poin, dan naik ke 17 atau 18 biaya 3 poin.

+-------+------+
| Score | Cost |
+-------+------+
|     8 |    0 |
|     9 |    1 |
|    10 |    2 |
|    11 |    3 |
|    12 |    4 |
|    13 |    5 |
|    14 |    6 |
|    15 |    8 |
|    16 |   10 |
|    17 |   13 |
|    18 |   16 |
+-------+------+

Dalam bentuk daftar:

[(8, 0), (9, 1), (10, 2), (11, 3), (12, 4), (13, 5), (14, 6), (15, 8), (16, 10), (17, 13), (18, 16)]

Biaya pembelian poin dirangkum untuk semua enam skor kemampuan.

Ability scores: 16   17   8  13   8  12
Point buy cost: 10 + 13 + 0 + 5 + 0 + 4  = 32

Diberikan enam skor kemampuan, masing-masing 8 hingga 18, menghasilkan total biaya pembelian poin. Bytes paling sedikit menang.

Tampilkan cuplikan kode

code-golf  arithmetic 
— Tidak
sumber
2
Ähm apakah hanya aku atau tantangan yang diberikan hilang? 0o
— Zaibis
1
@Zaibis Tidak yakin apa yang Anda maksud. Saya memasukkan "kemenangan byte paling sedikit" - maksud Anda?
— xnor
tmp blah blah untuk mengatakan: ya
— Zaibis

Jawaban:

11

JavaScript (ES7), 44 42 40 byte

Dicoret 44 masih teratur 44 :(

a=>a.map(s=>t+=s-9-~((s-14)**1.3),t=0)|t

Terima kasih kepada @apsillers untuk menghemat 2 byte!

Penjelasan

Bagian yang menarik adalah -1-~((s-14)**1.3). (s-14)**1.3memproduksi 1, 2, 4dan 6nilai-nilai 15 - 18. Angka apa pun yang kurang dari 15menyebabkan kesalahan karena implementasi JavaScript eksponensial tidak dapat beroperasi pada nilai negatif dengan eksponen fraksional. Pada dasarnya, nilai apa pun yang s < 15menyebabkannya kembali NaN, sehingga -1-~ada untuk melemparkannya ke angka ( 0).

a=>                       // a = input scores as an array of numbers
  a.map(s=>               // for each passed score
    t+=                   // add to the total
      s-9                 // point value = s - 8 (-1 used for next line)
      -~((s-14)**1.3),    // add extra points for scores 15 - 18
    t=0                   // t = total points (this happens BEFORE the map call)
  )
  |t                      // return the total points

Solusi ES6 (42 byte)

a=>a.map(s=>t+=s-9-~[1,2,4,6][s-15],t=0)|t

Uji

Tes ini Math.powsebagai gantinya menggunakan operator eksponensial ( **) sehingga dapat berjalan di browser standar apa pun.

Tampilkan cuplikan kode

— pengguna81655
sumber
Satu byte lagi: gunakan |tsebagai ganti &&t. The ECMAScript operasiToInt32 akan selalu memaksa hasil mapdi sini untuk 0, karena array multi-elemen akan selalu ToNumber-ify ke NaN. (Ini akan menjadi masalah jika spec memperbolehkan array elemen tunggal sebagai input, tetapi membutuhkan 6 elemen.)
— apsillers
@apsillers Ooh, itu tip yang bagus! Terima kasih
— user81655
8

CJam, 18 byte

l~[8EG]ff-:~0fe>:+

atau

l~[8EG]m*::m0fe>:+

Uji di sini.

Penjelasan

Idenya adalah menguraikan biaya poin menjadi tiga komponen:

 Score: 8  9 10 11 12 13 14 15 16 17 18
        0  1  2  3  4  5  6  7  8  9 10
        0  0  0  0  0  0  0  1  2  3  4
        0  0  0  0  0  0  0  0  0  1  2
       --------------------------------
 Cost:  0  1  2  3  4  5  6  8 10 13 16

Ketiga komponen dapat dihitung melalui pengurangan tunggal dan membatasi hasilnya ke nilai-nilai non-negatif.

l~    e# Read and evaluate input.
[8EG] e# Push [8 14 16].
ff-   e# For each pair from the two lists, subtract one from the other. 
:~    e# Flatten the result.
0fe>  e# Clamp each difference to non-negative values.
:+    e# Sum them all up.
— Martin Ender
sumber
8

Pyth, 14 byte

s>#0-M*Q+14yB8

Suite uji

Ini menggunakan cara perhitungan fundamental yang sama dengan Martin Büttner, yaitu:

max(n-8, 0) + max(n-14, 0) + max(n-16, 0)

Karena itu, cara perhitungannya sangat berbeda. Untuk menghasilkan daftar angka untuk dikurangi, saya menggunakan ekspresi +14yB8. yB8berarti "Bifurcate 8 pada fungsi y". y menggandakan angka, jadi ini memberi [8, 16]. Kemudian, kami menambahkan pada 14, memberikan daftar [14, 8, 16].

Selanjutnya, kami mengambil produk Cartesian dengan input dan mengurangi setiap pasangan nilai.

Selanjutnya, lakukan operasi pemaksimalan, kami cukup memfilter untuk nilai positif saja, dan menjumlahkan sisanya.

— isaacg
sumber
4

Samau , 19 byte

Tidak yakin apakah pertanyaannya diposting setelah komit terakhir dari bahasa baru saya. Keduanya 2 jam yang lalu. Tetapi semua fitur yang digunakan di sini ditambahkan sebelum itu.

▐[8 14 16]`-o;0>*ΣΣ

Samau menggunakan CP737 sebagai pengkodean karakter standarnya.

▐[8 14 16]`-o;0>*ΣΣ
▐                      read a list of numbers
 [8 14 16]             push [8 14 16]
          `-           push the function [-]
            o          outer product
             ;         duplicate
              0>       for each element, test if it's larger than 0
                *      times
                 ΣΣ    take the sum twice because it's a 2d array
— alephalpha
sumber
0

PowerShell, 48 Bytes

$args|%{$t+=$_-8+@{15=1;16=2;17=4;18=10}[$_]};$t

(Cukup yakin ini tidak optimal.)

Membawa argumen baris perintah input dan memiparnya menjadi satu lingkaran |%{...}. Setiap iterasi, kami menambah total kami $t+=dengan angka saat ini minus 8 $_-8ditambah hasil pengindeksan menjadi hashtable untuk nilai yang lebih mahal @{...}[$_]. Maka kita cukup output $tpada akhirnya.

— AdmBorkBork
sumber
0

(🐂👍) Ox ++, 248 byte (62 karakter)

🐀👉🌑👺🐁👉🌑👺😂🐀🐟🌗😂🐂👉😷😺😺😷👺🐁👉🐁👏🐂🙌🌙👏🌜🐂🐳🌒🌕🌛👥🌜🐂🙌🌒🌕🌛👏🌜🐂🐳🌒🌗🌛👥🌜🐂🙌🌒🌗🌛👺🐀👍😂👄🐁👄

Bahasa yang saya kerjakan. Rekatkan kode di sini .

— geokavel
sumber
Browser saya hanya dapat menampilkan 7 karakter ini.
— isaacg
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.