Custo de compra do ponto de D&D

20

Ao criar um personagem de Dungeons & Dragons , uma alternativa às pontuações das habilidades de rolagem é atribuí-las a um orçamento de energia chamado compra por pontos. Pontuações de habilidades mais altas custam mais pontos, especialmente no extremo superior: uma pontuação de 8 é gratuita e aumentar 1 em 1 custa 1 ponto, exceto aumentar para 15 ou 16 custa 2 pontos e aumentar para 17 ou 18 custa 3 pontos.

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

Em forma de lista:

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

O custo de compra de pontos é somado para todas as seis pontuações de habilidade.

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

Dadas seis pontuações de habilidade, cada uma com 8 a 18, resultam no custo total de compra de pontos. Menos bytes ganha.

Mostrar snippet de código

code-golf arithmetic xnor
fonte
2
Ah, sou apenas eu ou falta o desafio em questão? 0o
Zaibis 23/12/2015
1
@Zaibis Não sei o que você quer dizer. Coloquei "o menor número de bytes ganhos" - você quis dizer isso?
Xnor
tmp blá blá para dizer: sim
Zaibis

Respostas:

11

JavaScript (ES7), 44 42 40 bytes

Riscado 44 ainda é regular 44 :(

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

Obrigado ao @apsillers por economizar 2 bytes!

Explicação

A parte interessante é -1-~((s-14)**1.3). (s-14)**1.3produz 1, 2, 4e 6para os valores 15 - 18. Qualquer número menor que 15causa um erro porque a implementação exponencial do JavaScript não pode operar com valores negativos com um expoente fracionário. Basicamente, qualquer valor para s < 15faz com que ele retorne NaN; portanto, -1-~existe para convertê-lo em um número ( 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

Solução ES6 (42 bytes)

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

Teste

Este teste usa, em Math.powvez disso, o operador exponencial ( **) para que ele possa ser executado em qualquer navegador padrão.

Mostrar snippet de código

user81655
fonte
Mais um byte: use em |tvez de &&t. A operação ECMAScriptToInt32 sempre coagirá o resultado de mapaqui para 0, porque matrizes de vários elementos sempre serão ToNumberidentificadas como NaN. (Este seria um problema se a especificação permitido matrizes de um único elemento de entrada como, mas requer elementos 6.)
apsillers
@apsillers Ooh, essa é uma boa dica! Graças
user81655
8

CJam, 18 bytes

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

ou

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

Teste aqui.

Explicação

A ideia é decompor o custo pontual em três componentes:

 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

Todos os três componentes podem ser calculados por meio de uma única subtração e restringir o resultado a valores não negativos.

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
fonte
8

Pitão, 14 bytes

s>#0-M*Q+14yB8

Suíte de teste

Isso usa os mesmos meios fundamentais de cálculo que Martin Büttner, a saber:

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

Dito isto, os meios de cálculo são muito diferentes. Para gerar a lista de números para subtrair, eu uso a expressão +14yB8. yB8significa "Bifurcar 8 na função y". y dobra números, então isso dá [8, 16]. Em seguida, adicionamos o 14, fornecendo a lista [14, 8, 16].

Em seguida, pegamos o produto cartesiano com a entrada e subtraímos cada par de valores.

Em seguida, execute a operação de maximização, basta filtrar apenas valores positivos e somar o restante.

isaacg
fonte
4

Samau , 19 bytes

Não tenho certeza se a pergunta foi publicada após o último commit do meu novo idioma. Ambos são 2 horas atrás. Mas todos os recursos usados ​​aqui foram adicionados antes disso.

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

A Samau usa o CP737 como codificação de caracteres padrão.

▐[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
alefalpha
fonte
0

PowerShell, 48 bytes

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

(Com certeza isso não é o ideal.)

Pega argumentos de linha de comando de entrada e os canaliza em um loop |%{...}. A cada iteração, incrementamos nosso total $t+=com o número atual menos 8 $_-8mais o resultado da indexação em uma hashtable para os valores mais caros @{...}[$_]. Então nós simplesmente produzimos $tno final.

AdmBorkBork
fonte
0

(🐂👍) Ox ++, 248 bytes (62 caracteres)

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

Idioma em que estou trabalhando. Cole o código aqui .

geokavel
fonte
Meu navegador pode exibir apenas sete desses caracteres.
Isaacg