Chỉnh sửa : Trước đây tôi chưa chơi D & D nên khi ban đầu tôi đặt câu hỏi này, tôi đã không nghiên cứu kỹ về nó. Tôi xin lỗi vì điều này và tôi đang thực hiện một vài chỉnh sửa có thể làm mất hiệu lực các câu trả lời để giữ đúng nhất có thể với các quy tắc dnd 5e. Lấy làm tiếc.

Một người hâm mộ D & D từ một câu hỏi về mạng nóng gần đây dường như có một số vấn đề khi tìm hiểu xem một phép thuật được chọn có phù hợp với khả năng hay không - và tôi nghĩ chúng ta nên giúp đỡ!

Giới thiệu

(tất cả điều này đã được mô tả trong câu hỏi đã đề cập trước đó)

Một thầy phù thủy biết hai phép thuật cấp 1 từ đầu (cấp 1): [1, 1]

• Mỗi khi một thầy phù thủy đạt được một cấp độ (ngoại trừ các cấp 12, 14, 16, 18, 19 và 20), họ học được một câu thần chú mới (bắt buộc).

• Ngoài ra, khi lên cấp, người ta có thể chọn (tùy chọn) để thay thế một trong những phép thuật khác.

Các phép thuật được học và thay thế phải là một cấp độ chính tả hợp lệ, bằng một nửa cấp độ phù thủy của bạn được làm tròn. Xem bảng này:

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

Điều này có nghĩa là ở cấp 3, người ta có thể có các cấp chính tả [1, 1, 2, 2]như thế này:

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

Không bắt buộc phải chọn các phép thuật cấp cao nhất mà bạn có quyền truy cập.

Các cấp chính tả [1, 1, 1, 1]hoàn toàn hợp lệ cho cấp 3.

Cuối cùng, hãy nhớ rằng thay thế một câu thần chú là một tùy chọn tùy chọn cho mọi cấp độ . Điều này có nghĩa là một số cấp có thể bỏ qua thay thế, trong khi các cấp khác sử dụng nó.

Các thách thức

Tạo một chương trình hoặc hàm lấy một số nguyên (cấp) trong khoảng từ 1 đến 20.

Nó cũng nên lấy một mảng các số nguyên (cấp chính tả) với các giá trị nằm trong khoảng từ 1 đến 9 theo bất kỳ thứ tự nào (9 là mức chính tả tối đa).

Đầu ra của chương trình phải là một giá trị trung thực / giả mạo nếu các mức chính tả được chọn là hợp lệ cho một thầy phù thủy của cấp độ đã cho.

Các trường hợp thử nghiệm

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]

Đây là mã golf - ít byte thắng nhất!

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

Hãy thử trực tuyến!

• Yêu cầu đầu vào: danh sách chính tả phải được sắp xếp từ cấp chính tả lớn nhất đến cấp thấp nhất.

Giải thích

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

Bảng 1: Phân phối chính tả tối đa cho mỗi cấp độ phù thủy, được sử dụng từ câu trả lời của Axoren cho câu hỏi được liên kết .

Tín dụng

• Đã lưu 14 byte nhờ 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)

Hãy thử trực tuyến!

Ung dung:

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)

chỉnh sửa: giải pháp chính xác để sử dụng đúng quy tắc D & D

Than , 51 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Lấy các cấp chính tả theo thứ tự tăng dần dưới dạng một chuỗi. Giải trình:

Ｎθ

Nhập cấp.

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

Thực hiện giải mã độ dài chạy trên chuỗi 0544443335dẫn đến chuỗi 11111222233334444555566677788899999. Chuỗi này sau đó được cắt bắt đầu ở cấp độ (1 chỉ mục) và kết thúc ở cấp độ nhân đôi (nếu dưới 12) hoặc 6 + 1,5 *, được làm tròn lên, ngoại trừ cấp 19, được làm tròn xuống. A 0được thêm vào để đảm bảo rằng không có quá nhiều phép thuật.

¬ΣＥＳ›ι§θκ

So sánh các mức chính tả với chuỗi con và in -nếu không có lỗi nào trong số chúng là quá mức.

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

Hãy thử trực tuyến!

Mã kiểm tra

Dưới đây là một liên kết đến một số mã kiểm tra lấy mức phù thủy làm đầu vào và trả về một mảng các mức chính tả tối đa, sử dụng logic tương tự như hàm trên.

Hãy thử trực tuyến!

Làm sao?

Bảng tham khảo

 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 

Số lượng phép thuật

$L$$N_L$

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

Mức chính tả tối đa

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

Tạo sách chính tả tốt nhất có thể, sau đó kiểm tra xem sách chính tả được truyền vào phương thức không tốt hơn.

Ungolfed, với các loại ngầm định được thực hiện rõ ràng:

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
}

Hãy thử trực tuyến!