Sunting : Saya belum pernah bermain D & D sebelumnya jadi ketika saya awalnya membuat pertanyaan ini saya tidak benar meneliti itu. Saya minta maaf untuk ini, dan saya membuat beberapa pengeditan yang mungkin membatalkan jawaban untuk tetap setepat mungkin pada aturan 5nd. Maaf.

Penggemar D & D dari Hot Network Question baru-baru ini tampaknya memiliki masalah untuk mengetahui apakah mantra yang dipilih oleh penyihir sejajar dengan kemungkinan - dan saya pikir kita harus membantu!

pengantar

(semua ini sudah dijelaskan dalam pertanyaan yang disebutkan sebelumnya)

Seorang penyihir tahu dua mantra level 1 dari awal (level 1): [1, 1]

• Setiap kali penyihir mendapatkan level (kecuali untuk level 12, 14, 16, 18, 19 dan 20) mereka belajar mantra baru (wajib).

• Selain itu, ketika naik level seseorang dapat memilih (opsional) untuk mengganti salah satu mantra dengan yang lain.

Mantra yang dipelajari dan diganti haruslah level slot mantera yang valid yang setengah dari level penyihirmu dibulatkan. Lihat tabel ini:

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

Ini berarti pada level 3 seseorang dapat memiliki level mantra [1, 1, 2, 2]seperti ini:

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

Tidak perlu memilih mantra level tertinggi yang bisa Anda akses.

Level mantra [1, 1, 1, 1]sangat valid untuk level 3.

Terakhir, ingat bahwa mengganti mantra adalah opsi opsional untuk setiap level . Ini berarti bahwa beberapa level dapat melewati penggantian, sementara yang lain memanfaatkannya.

Tantangan

Buat program atau fungsi yang membutuhkan bilangan bulat (level) antara 1 dan 20.

Itu juga harus mengambil array bilangan bulat (level mantra) dengan nilai mulai dari 1 hingga 9 dalam urutan apa pun (9 adalah level mantra maksimum).

Output dari program harus berupa nilai kebenaran / kepalsuan yang memvalidasi jika level mantra yang dipilih valid untuk penyihir dari level yang diberikan.

Uji kasus

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]

Ini adalah kode-golf - byte terkecil menang!

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

Cobalah online!

• Persyaratan input: daftar mantra harus dipesan dari tingkat mantra terbesar hingga terendah.

Penjelasan

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

Tabel 1: Distribusi mantra dimaksimalkan untuk setiap tingkat penyihir, digunakan dari jawaban Axoren pada pertanyaan terkait .

Kredit

• Disimpan 14 byte berkat Kevin Cruijssen .

Python 3 , 98 byte

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)

Cobalah secara Online!

Tidak Disatukan:

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)

sunting: solusi yang diperbaiki untuk menggunakan aturan D & D yang benar

Arang , 51 byte

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Mengambil level mantra dalam urutan naik sebagai string. Penjelasan:

Ｎθ

Masukkan level.

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

Lakukan decoding run-length pada string yang 0544443335menghasilkan string 11111222233334444555566677788899999. String ini kemudian diiris mulai dari level (1-diindeks) dan berakhir di level dua kali lipat (jika kurang dari 12) atau 6 + 1,5 *, dibulatkan ke atas, kecuali untuk level 19, yang dibulatkan ke bawah. A 0diberi sufiks untuk memastikan tidak ada terlalu banyak mantra.

¬ΣＥＳ›ι§θκ

Bandingkan level mantra dengan substring dan cetak a -jika tidak ada yang berlebihan.

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

Cobalah online!

Kode uji

Di bawah ini adalah tautan ke beberapa kode uji yang mengambil tingkat penyihir sebagai input dan mengembalikan array level mantra maksimum, menggunakan logika yang sama dengan fungsi di atas.

Cobalah online!

Bagaimana?

Tabel referensi

 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 

Jumlah mantra

$L$$N_L$

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

Level mantra maksimum

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

$x$$a$

Groovy , 155 byte

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}

Menghasilkan spellbook terbaik, lalu memeriksa apakah spellbook yang masuk ke metode tidak lebih baik.

Tidak disatukan, dengan tipe implisit yang dibuat eksplisit:

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
}

Cobalah online!