Costo di acquisto punto D&D

20

Quando crei un personaggio di Dungeons & Dragons , un'alternativa ai punteggi delle abilità di lancio è assegnarli all'interno di un budget di potere chiamato punto buy. I punteggi di abilità più alti costano più punti, specialmente verso l'estremità superiore: un punteggio di 8 è gratuito e alzare un punteggio di 1 costa 1 punto, tranne che aumentare a 15 o 16 costa 2 punti e alzare a 17 o 18 costa 3 punti.

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

In forma di elenco:

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

Il costo di acquisto punti viene sommato per tutti e sei i punteggi di abilità.

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

Dati sei punteggi di abilità, ciascuno da 8 a 18, hanno generato il costo totale di acquisto dei punti. Vince il minor numero di byte.

Mostra snippet di codice

code-golf  arithmetic 
— XNOR
fonte
2
Oh, sono solo io o manca la sfida data? 0o
— Zaibis,
1
@Zaibis Non sono sicuro di cosa intendi. Ho inserito "il minor numero di byte vincenti" - intendevi questo?
— xnor
tmp blah blah per dire: sì
— Zaibis il

Risposte:

11

JavaScript (ES7), 44 42 40 byte

Cancellato 44 è ancora regolare 44 :(

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

Grazie a @apsillers per aver salvato 2 byte!

Spiegazione

La parte interessante è -1-~((s-14)**1.3). (s-14)**1.3produce 1, 2, 4e 6per i valori 15 - 18. Qualsiasi numero inferiore a 15causa un errore perché l'implementazione JavaScript dell'esponente non può operare su valori negativi con un esponente frazionario. Fondamentalmente, qualsiasi valore per s < 15fa sì che ritorni NaN, quindi -1-~è lì per lanciarlo su un numero ( 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

Soluzione ES6 (42 byte)

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

Test

Questo test utilizza Math.powinvece l'operatore esponenziale ( **) in modo che possa essere eseguito in qualsiasi browser standard.

Mostra snippet di codice

— user81655
fonte
Un altro byte: usare |tinvece di &&t. L' operazione ECMAScriptToInt32 costringerà sempre il risultato di mapqui a 0, poiché le matrici multi-elemento si ToNumberidentificheranno sempre a NaN. (Questo sarebbe un problema se la specifica consentisse array a singolo elemento come input, ma richiede 6 elementi.)
— apsillers
@apsillers Ooh, è un bel consiglio! Grazie
— user81655 il
8

CJam, 18 byte

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

o

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

Provalo qui.

Spiegazione

L'idea è di scomporre il costo in punti in tre componenti:

 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

Tutti e tre i componenti possono essere calcolati tramite una singola sottrazione e limitando il risultato a valori non negativi.

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

Pyth, 14 byte

s>#0-M*Q+14yB8

Suite di test

Questo utilizza gli stessi mezzi di calcolo fondamentali di Martin Büttner, vale a dire:

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

Detto questo, i mezzi di calcolo sono molto diversi. Per generare l'elenco di numeri da sottrarre, utilizzo l'espressione +14yB8. yB8significa "Biforcazione 8 sulla funzione y". y raddoppia i numeri, quindi questo dà [8, 16]. Quindi, aggiungiamo 14, dando l'elenco [14, 8, 16].

Successivamente, prendiamo il prodotto cartesiano con l'input e sottraggiamo ogni coppia di valori.

Successivamente, eseguiamo l'operazione di massimizzazione, filtriamo semplicemente solo i valori positivi e sommiamo il resto.

— isaacg
fonte
4

Samau , 19 byte

Non sono sicuro se la domanda viene pubblicata dopo l'ultimo commit della mia nuova lingua. Sono entrambi 2 ore fa. Ma tutte le funzionalità utilizzate qui sono state aggiunte prima.

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

Samau utilizza CP737 come codifica dei caratteri predefinita.

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

PowerShell, 48 byte

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

(Abbastanza sicuro che questo non sia ottimale.)

Accetta gli argomenti della riga di comando di input e li inserisce in un ciclo |%{...}. Ad ogni iterazione, incrementiamo il nostro totale $t+=con il numero corrente meno 8 $_-8più il risultato dell'indicizzazione in una tabella hash per i valori più costosi @{...}[$_]. Quindi abbiamo semplicemente prodotto $talla fine.

— AdmBorkBork
fonte
0

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

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

Lingua su cui sto lavorando. Incolla il codice qui .

— geokavel
fonte
Il mio browser può visualizzare solo 7 di questi caratteri.
— isaacg,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.