Bearbeiten : Ich habe D & D noch nie gespielt. Als ich diese Frage zum ersten Mal stellte, habe ich sie nicht richtig recherchiert. Ich entschuldige mich dafür und nehme einige Änderungen vor, die die Antworten ungültig machen könnten, um den dnd 5e-Regeln so treu wie möglich zu bleiben. Es tut uns leid.

Ein D & D-Fan aus einer aktuellen Hot Network-Frage scheint Schwierigkeiten zu haben, herauszufinden, ob die von einem Zauberer gewählten Zaubersprüche mit den Möglichkeiten übereinstimmen - und ich denke, wir sollten helfen!

Einführung

(All dies ist bereits in der zuvor genannten Frage beschrieben)

Ein Zauberer kennt von Anfang an zwei Zaubersprüche der Stufe 1 (Stufe 1): [1, 1]

• Jedes Mal, wenn ein Zauberer eine Stufe erreicht (mit Ausnahme der Stufen 12, 14, 16, 18, 19 und 20), lernt er einen neuen Zauber (obligatorisch).

• Außerdem, wenn man wählen (optional) Nivellierung kann ersetzen eine der Zauber mit einem anderen.

Die gelernten und ersetzten Zaubersprüche müssen eine gültige Zauberslot-Stufe sein, die die Hälfte der aufgerundeten Stufe Ihres Zauberers ist. Siehe diese Tabelle:

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

Dies bedeutet, dass man auf Stufe 3 die folgenden Zauberstufen haben kann [1, 1, 2, 2]:

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

Es ist nicht erforderlich, die Zaubersprüche der höchsten Stufe auszuwählen, auf die Sie Zugriff haben.

Die Zauberstufen [1, 1, 1, 1]gelten perfekt für Stufe 3.

Denken Sie zum Schluss daran, dass das Ersetzen eines Zaubers eine optionale Option für jedes Level ist . Dies bedeutet, dass einige Ebenen das Ersetzen überspringen können, während andere davon Gebrauch machen.

Die Herausforderung

Erstellen Sie ein Programm oder eine Funktion, die eine Ganzzahl (Ebene) zwischen 1 und 20 annimmt.

Es sollte auch ein Array von ganzen Zahlen (Zauberstufen) mit Werten zwischen 1 und 9 in beliebiger Reihenfolge verwendet werden (9 ist die maximale Zauberstufe).

Die Ausgabe des Programms sollte ein Wahrheits- / Falschwert sein, der überprüft, ob die gewählten Zauberstufen für einen Zauberer der gegebenen Stufe gültig sind.

Testfälle

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]

Das ist Code-Golf - die wenigsten Bytes gewinnen!

Java (JDK 10) , 191 Byte

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;}

Probieren Sie es online aus!

• Eingabeanforderung: Die Zauberliste muss von der höchsten bis zur niedrigsten Zauberstufe geordnet werden.

Erklärungen

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.
}

Tabelle 1: Maximierte Zauberverteilung für jede Zaubererstufe, verwendet aus Axorens Antwort auf die verknüpfte Frage .

Credits

• 14 Bytes dank Kevin Cruijssen gespart .

Python 3 , 98 Bytes

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)

Probieren Sie es online aus!

Ungolfed:

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: korrigierte Lösung zur Verwendung korrekter D & D-Regeln

Holzkohle , 51 Bytes

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

Probieren Sie es online aus! Der Link führt zur ausführlichen Version des Codes. Nimmt Zauberstufen in aufsteigender Reihenfolge als Zeichenfolge. Erläuterung:

Ｎθ

Geben Sie den Pegel ein.

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

Führen Sie eine Lauflängendecodierung für die Zeichenfolge 0544443335durch, die zur Zeichenfolge führt 11111222233334444555566677788899999. Diese Zeichenfolge wird dann beginnend mit der Ebene (1-indiziert) geschnitten und endet mit der doppelten Ebene (wenn weniger als 12) oder 6 + 1,5 *, aufgerundet, mit Ausnahme der Ebene 19, die abgerundet ist. A 0wird mit einem Suffix versehen, um sicherzustellen, dass nicht zu viele Zaubersprüche vorhanden sind.

¬ΣＥＳ›ι§θκ

Vergleichen Sie die Zauberstufen mit der Teilzeichenfolge und drucken Sie a, -wenn keine davon übermäßig ist.

JavaScript (ES6), 79 Byte

(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

Probieren Sie es online aus!

Testcode

Unten finden Sie einen Link zu einem Testcode, der die Zaubererstufe als Eingabe verwendet und ein Array maximaler Zauberstufen zurückgibt, wobei dieselbe Logik wie bei der obigen Funktion verwendet wird.

Probieren Sie es online aus!

Wie?

Referenztabelle

 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 

Anzahl der Zauber

$L$$N_L$

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

Maximale Zauberstufe

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

$x$$a$

Groovy , 155 Bytes

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}

Erzeugt das bestmögliche Zauberbuch und überprüft dann, ob das an die Methode übergebene Zauberbuch nicht besser ist.

Ungolfed, mit explizit angegebenen impliziten Typen:

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
}

Probieren Sie es online aus!