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
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
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
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
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
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
source
0

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

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

Langue sur laquelle je travaille. Collez le code ici .

— geokavel
source
Mon navigateur ne peut afficher que 7 de ces caractères.
— isaacg
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.