Edit : Je n'ai jamais joué à D&D auparavant, donc lorsque j'ai posé cette question au départ, je ne l'ai pas bien recherchée. Je m'en excuse, et je fais quelques modifications qui pourraient invalider les réponses pour rester aussi fidèles que possible aux règles du dnd 5e. Désolé.

Un fan de D&D d'une récente question de Hot Network semble avoir du mal à déterminer si les sorts choisis par un sorcier correspondent aux possibilités - et je pense que nous devrions aider!

introduction

(tout cela est déjà décrit dans la question précédente)

Un sorcier connaît deux sorts de niveau 1 depuis le début (niveau 1): [1, 1]

• Chaque fois qu'un sorcier gagne un niveau (sauf pour les niveaux 12, 14, 16, 18, 19 et 20), il apprend un nouveau sort (obligatoire).

• De plus, lorsque vous passez au niveau supérieur, vous pouvez choisir (facultatif) de remplacer l' un des sorts par un autre.

Les sorts appris et remplacés doivent être un niveau d'emplacement de sort valide qui correspond à la moitié du niveau de votre sorcier arrondi. Voir ce tableau:

Sorcerer level  Highest spell level possible
1               1
2               1
3               2
4               2
5               3
6               3
7               4
8               4
9               5
10              5
11              6
12              6
13              7
14              7
15              8
16              8
17              9
18              9
19              9
20              9

Cela signifie qu'au niveau 3, on peut avoir les niveaux de sort [1, 1, 2, 2]comme ceci:

Level 1: [1, 1] (initial)
Level 2: [1, 1, 1 (new)]
Level 3: [1, 1, 2 (replaced), 2 (new)]

Il n'est pas nécessaire de choisir les sorts de plus haut niveau auxquels vous avez accès.

Les niveaux des sorts [1, 1, 1, 1]sont parfaitement valables pour un niveau 3.

Enfin, n'oubliez pas que le remplacement d'un sort est une option facultative pour chaque niveau . Cela signifie que certains niveaux peuvent ignorer le remplacement, tandis que d'autres s'en servent.

Le défi

Créez un programme ou une fonction qui prend un entier (niveau) compris entre 1 et 20.

Il doit également prendre un tableau d'entiers (niveaux de sort) avec des valeurs allant de 1 à 9 dans n'importe quel ordre (9 est le niveau de sort maximum).

La sortie du programme doit être une valeur de vérité / fausse validant si les niveaux de sort choisis sont valables pour un sorcier du niveau donné.

Cas de test

Level: 1
Spells: [1, 1]
Output: true

Level: 8
Spells: [1, 1, 2, 3, 3, 5]
Ouput: false

Reason: A level 8 can't ever have access to a level 5 spell.

Level: 5
Spells: [1, 1, 1, 2, 2, 2, 3]
Output: false

Reason: A level 5 can't have access to 7 spells

Level: 11
Spells: [3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6]
Output: false

Reason: Too many spell upgrades.
        The highest valid selection for level 11 is
        [3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6]

C'est le golf de code - le moins d'octets gagne!

Java (JDK 10) , 191 octets

L->S->{int m[]=new int[9],z=0,Z=0,l=0;for(m[0]++;l++<L;z+=--m[z]<1?1:0)m[Z=~-l/2-l/19]+=l<12?2:l>17?1:1+l%2;l=0;for(int s:S){if(--s>Z)l++;Z-=--m[Z>0?Z:0]<1?1:0;}for(int i:m)l|=i;return l==0;}

Essayez-le en ligne!

• Condition d'entrée: la liste des sorts doit être classée du plus grand niveau du sort au plus bas.

Explications

L->S->{                                        // Curried-lambda with 2 parameters: sorcerer-level and spell list
 int m[]=new int[9],                           // Declare variables: m is the max level  of each spell.
     z=0,                                      // z is the minimum spell level of the maximized spell list.
     Z=0,                                      // Z is the maximum spell level for the current level.
     l=0;                                      // l is first a level counter, then a reused variable
 for(m[0]++;l++<L;z+=--m[z]<1?1:0)             // for each level, compute the maximized known spells.
  m[Z=~-l/2-l/19]+=l<12?2:l>17?1:1+l%2;        // 
                                               // Now m is the row for level L in the table below.
 l=0;                                          // l now becomes an error indicator
 for(int s:S){                                 // This loop checks if the spell-list matches the spells allowed for that level.
  if(--s>Z)l++;                                // Spell-levels are 1-based, my array is 0-based so decrease s.
  Z-=--m[Z>0?Z:0]<1?1:0;                       // Remove a max level if we've expleted all the spells, avoiding exception.
 }                                             //
 for(int i:m)l|=i;                             // Make sure there are no more values in m.
 return l==0;                                  // Return true if no miscount were encountered.
}

Tableau 1: Distribution maximisée des sorts pour chaque niveau de sorcier, utilisée à partir de la réponse d' Axoren à la question liée .

Crédits

• Enregistré 14 octets grâce à Kevin Cruijssen .

Python 3 , 98 octets

v=lambda L,S:(max(S)*2-2<L)&v(L-1,[1]+sorted(S)[:(chr(L*3)in'$*069<')-2])if L>1else(1,1)==tuple(S)

Essayez-le en ligne!

Non golfé:

def v(L, S):
    # recursion base case
    if L <= 1:
        return tuple(S) == (1, 1)
    # if the highest level skill is not valid for the level, then return False.
    if max(S)*2 - 2 < L:
        return False
    # hacky way to determine if the level gets a new skill
    has_new_skill = chr(L*3) in '$*069<'
    sorted_skills = sorted(S)
    # this step removes the highest skill and adds a level 1 skill (replacement)
    # if there is a new skill, then it removes the second highest skill as well
    new_skills = [1] + sorted_skills[:has_new_skill - 2]
    return v(L-1, new_skills)

edit: solution corrigée pour utiliser les règles D&D correctes

Fusain , 51 octets

Ｎθ≔⁺✂⭆”)⊟⊞<⁴H”×ＩκＩιθ⎇‹θ¹²⊕⊗θ⁺⁶⁺θ⊘⁺‹θ¹⁹θ¹0θ¬ΣＥＳ›ι§θκ

Essayez-le en ligne! Le lien est vers la version détaillée du code. Prend les niveaux des sorts en ordre croissant sous forme de chaîne. Explication:

Ｎθ

Saisissez le niveau.

≔⁺✂⭆”)⊟⊞<⁴H”×ＩκＩιθ⎇‹θ¹²⊕⊗θ⁺⁶⁺θ⊘⁺‹θ¹⁹θ¹0θ

Effectuez un décodage de longueur d'exécution sur la chaîne 0544443335résultant en la chaîne 11111222233334444555566677788899999. Cette chaîne est ensuite tranchée en commençant au niveau (1-indexé) et se terminant au niveau doublé (si moins de 12) ou 6 + 1,5 *, arrondi vers le haut, sauf pour le niveau 19, qui est arrondi vers le bas. A 0est suffixé pour s'assurer qu'il n'y a pas trop de sorts.

¬ΣＥＳ›ι§θκ

Comparez les niveaux des sorts avec la sous-chaîne et affiche a -si aucun d'entre eux n'est excessif.

JavaScript (ES6), 79 octets

(level)(array)$0$$1$

l=>a=>!a.some(x=>x>(j--,++l>30?9:l+(l<25?2:4)>>2),j=l<12?l:l>16?14:l+11>>1)&!~j

Essayez-le en ligne!

Code de test

Vous trouverez ci-dessous un lien vers un code de test qui prend le niveau du sorcier en entrée et renvoie un tableau de niveaux de sort maximum, en utilisant la même logique que la fonction ci-dessus.

Essayez-le en ligne!

Comment?

Table de référence

 Sorcerer level | # of spells | Maximum spell levels          
----------------+-------------+-------------------------------
        1       |      2      | 1,1                           
        2       |      3      | 1,1,1                         
        3       |      4      | 1,1,2,2                       
        4       |      5      | 1,2,2,2,2                     
        5       |      6      | 2,2,2,2,3,3                   
        6       |      7      | 2,2,2,3,3,3,3                 
        7       |      8      | 2,2,3,3,3,3,4,4               
        8       |      9      | 2,3,3,3,3,4,4,4,4             
        9       |     10      | 3,3,3,3,4,4,4,4,5,5           
       10       |     11      | 3,3,3,4,4,4,4,5,5,5,5         
       11       |     12      | 3,3,4,4,4,4,5,5,5,5,6,6       
       12       |     12      | 3,4,4,4,4,5,5,5,5,6,6,6       
       13       |     13      | 4,4,4,4,5,5,5,5,6,6,6,7,7     
       14       |     13      | 4,4,4,5,5,5,5,6,6,6,7,7,7     
       15       |     14      | 4,4,5,5,5,5,6,6,6,7,7,7,8,8   
       16       |     14      | 4,5,5,5,5,6,6,6,7,7,7,8,8,8   
       17       |     15      | 5,5,5,5,6,6,6,7,7,7,8,8,8,9,9 
       18       |     15      | 5,5,5,6,6,6,7,7,7,8,8,8,9,9,9 
       19       |     15      | 5,5,6,6,6,7,7,7,8,8,8,9,9,9,9 
       20       |     15      | 5,6,6,6,7,7,7,8,8,8,9,9,9,9,9 

Nombre de sorts

$L$$N_L$

$j$$N_L-1$$-1$

Niveaux de sort maximum

$L$$1\le i \le N_L$$M_{L,i}$$i$

$x$$a$

Groovy , 155 octets

def f(int[]a, int b){l=[1]
b.times{n->l[0]=++n%2?n/2+1:n/2
if(n<18&(n<12|n%2>0))l.add(l[0])
l.sort()}
for(i=0;i<a.size();)if(a[i]>l[i++])return false
true}

Génère le meilleur grimoire possible, puis vérifie que le grimoire passé dans la méthode n'est pas meilleur.

Non golfé, avec des types implicites rendus explicites:

boolean spellChecker(int[] a, int b) {
    // l will be our best possible spellbook
    List<BigDecimal> l = [1]
    b.times { n ->
        n++ // iterate from 1 to b, not 0 to b-1
        l[0] = n % 2 != 0 ? n / 2 + 1 : n / 2 // update the lowest value to the best permitted
        if (n < 18 & (n < 12 | n % 2 > 0))
            l.add(l[0]) // if permitted, add another best spell
        l.sort() // ensure 0th position is always worst, ready for updating next loop
    }
    for (int i = 0; i < a.size(); i++)
        if (a[i] > l[i]) // if the submitted spell is of a higher level
            return false // also rejects when l[i] is undefined. (too many spells)
    return true
}

Essayez-le en ligne!