Coût d'achat d'un point D&D

20

Lorsque vous créez un personnage Dungeons & Dragons , une alternative aux scores de capacité de roulement consiste à les affecter dans un budget de puissance appelé achat de points. Des scores de capacité plus élevés coûtent plus de points, en particulier vers le haut: un score de 8 est gratuit, et augmenter un score de 1 coûte 1 point, sauf que monter à 15 ou 16 coûte 2 points, et augmenter à 17 ou 18 coûte 3 points.

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

Sous forme de liste:

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

Le coût d'achat de points est additionné pour les six scores de capacité.

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

Étant donné six scores de capacité, chacun de 8 à 18, affiche le coût total d'achat de points. Le moins d'octets gagne.

Afficher l'extrait de code

code-golf arithmetic xnor
la source
2
Ähm est-ce juste moi ou le défi donné est-il manquant? 0o
Zaibis
1
@Zaibis Je ne sais pas ce que tu veux dire. J'ai mis "le moins d'octets possible" - vouliez-vous dire cela?
xnor
tmp blah blah pour dire:
oui

Réponses:

11

JavaScript (ES7), 44 42 40 octets

Barré 44 est toujours régulier 44 :(

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

Merci à @apsillers d' avoir économisé 2 octets!

Explication

La partie intéressante est -1-~((s-14)**1.3). (s-14)**1.3produit 1, 2, 4et 6pour les valeurs 15 - 18. Tout nombre inférieur à 15provoque une erreur car l'implémentation JavaScript d'exponentielle ne peut pas fonctionner sur des valeurs négatives avec un exposant fractionnaire. Fondamentalement, toute valeur de for le s < 15renvoie NaN, donc le -1-~est là pour le convertir en un nombre ( 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

Solution ES6 (42 octets)

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

Tester

Ce test utilise à la Math.powplace l'opérateur exponentiel ( **) afin qu'il puisse s'exécuter dans n'importe quel navigateur standard.

Afficher l'extrait de code

user81655
la source
Un octet de plus: utilisez |tau lieu de &&t. L' opération ECMAScriptToInt32 toujours exercer des pressions sur le résultat d' mapici à 0, car les tableaux multi-éléments toujours ToNumber-ify à NaN. (Ce serait un problème si la spécification autorisait les tableaux à élément unique en entrée, mais cela nécessite 6 éléments.)
apsillers
@apsillers Ooh, c'est un bon conseil! Merci
user81655
8

CJam, 18 octets

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

ou

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

Testez-le ici.

Explication

L'idée est de décomposer le coût en points en trois composantes:

 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

Les trois composants peuvent être calculés via une seule soustraction et en restreignant le résultat à des valeurs non négatives.

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
la source
8

Pyth, 14 octets

s>#0-M*Q+14yB8

Suite de tests

Celui-ci utilise les mêmes moyens de calcul fondamentaux que Martin Büttner, à savoir:

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

Cela dit, les moyens de calcul sont très différents. Pour générer la liste des nombres à soustraire, j'utilise l'expression +14yB8. yB8signifie "Bifurquer 8 sur la fonction y". y double les nombres, donc cela donne [8, 16]. Ensuite, nous ajoutons le 14, donnant la liste [14, 8, 16].

Ensuite, nous prenons le produit cartésien avec l'entrée et soustrayons chaque paire de valeurs.

Ensuite, effectuez l'opération de maximisation, nous filtrons simplement les valeurs positives uniquement et additionnons le reste.

isaacg
la source
4

Samau , 19 octets

Je ne sais pas si la question est postée après le dernier commit de ma nouvelle langue. Ils sont tous les deux il y a 2 heures. Mais toutes les fonctionnalités utilisées ici ont été ajoutées avant cela.

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

Samau utilise CP737 comme encodage de caractères par défaut.

▐[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
la source
0

PowerShell, 48 octets

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

(Je suis sûr que ce n'est pas optimal.)

Prend les arguments de ligne de commande d'entrée et les canalise dans une boucle |%{...}. À chaque itération, nous incrémentons notre total $t+=avec le nombre actuel moins 8 $_-8plus le résultat de l'indexation dans une table de hachage pour les valeurs les plus chères @{...}[$_]. Ensuite, nous sortons simplement $tà la fin.

AdmBorkBork
la source
0

(🐂👍) Ox ++, 248 octets (62 caractères)

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

Langue sur laquelle je travaille. Collez le code ici .

geokavel
la source
Mon navigateur ne peut afficher que 7 de ces caractères.
isaacg