แก้ไข : ฉันไม่ได้เล่น D&D มาก่อนเมื่อฉันตั้งคำถามนี้ขึ้นมาฉันไม่ได้ค้นคว้าอย่างถูกต้อง ฉันขอโทษสำหรับสิ่งนี้และฉันกำลังแก้ไขบางอย่างที่อาจทำให้คำตอบไม่ถูกต้องเพื่อให้เป็นจริงที่สุดเท่าที่จะเป็นไปได้สำหรับกฎ dnd 5e ขอโทษ

แฟน D&D จากคำถามเครือข่ายร้อนแรงเมื่อไม่นานมานี้ดูเหมือนว่าจะมีปัญหาบางอย่างเกี่ยวกับว่านักเวทย์มนตร์ที่ถูกเลือกเข้าแถวสอดคล้องกับความเป็นไปได้หรือไม่ - และฉันคิดว่าเราควรช่วย!

บทนำ

(ทั้งหมดนี้ได้อธิบายไว้แล้วในคำถามที่กล่าวถึงก่อนหน้านี้)

นักเวทย์รู้สองคาถาระดับ 1 ตั้งแต่เริ่มต้น (ระดับ 1): [1, 1]

• ทุกครั้งที่นักเวทย์จะได้รับเลเวล (ยกเว้นเลเวล 12, 14, 16, 18, 19 และ 20) พวกเขาเรียนรู้คาถาใหม่ (จำเป็น)

• นอกจากนี้เมื่อปรับระดับขึ้นหนึ่งสามารถเลือก (ไม่จำเป็น) เพื่อแทนที่คาถาหนึ่งด้วยอีก

คาถาที่เรียนรู้และแทนที่จะต้องเป็นระดับสล็อตคาถาที่ถูกต้องซึ่งเป็นครึ่งหนึ่งของระดับจอมเวทย์ของคุณ ดูตารางนี้:

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

ซึ่งหมายความว่าที่ระดับ 3 หนึ่งสามารถมีระดับการสะกด[1, 1, 2, 2]เช่นนี้:

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

ไม่จำเป็นต้องเลือกคาถาระดับสูงสุดที่คุณสามารถเข้าถึงได้

ระดับเวทย์[1, 1, 1, 1]นั้นใช้ได้อย่างสมบูรณ์แบบสำหรับระดับ 3

สุดท้ายจำไว้ว่าการเปลี่ยนการสะกดเป็นตัวเลือกที่ไม่จำเป็นสำหรับทุกระดับ ซึ่งหมายความว่าบางระดับสามารถข้ามการแทนที่ในขณะที่คนอื่นใช้มัน

ความท้าทาย

ทำโปรแกรมหรือฟังก์ชั่นที่ใช้จำนวนเต็ม (ระดับ) ระหว่าง 1 ถึง 20

นอกจากนี้ควรใช้อาร์เรย์ของจำนวนเต็ม (ระดับการสะกด) ด้วยค่าตั้งแต่ 1 ถึง 9 ในลำดับใด ๆ (9 คือระดับการสะกดสูงสุด)

ผลลัพธ์ของโปรแกรมควรเป็นค่าการตรวจสอบความจริง / ความเท็จหากระดับการสะกดที่เลือกนั้นถูกต้องสำหรับนักเวทย์มนตร์ของระดับที่กำหนด

กรณีทดสอบ

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]

นี่คือcode-golf - ไบต์ที่น้อยที่สุดชนะ!

Java (JDK 10) , 191 ไบต์

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

ลองออนไลน์!

• ข้อกำหนดการป้อนข้อมูล:รายการคาถาต้องสั่งจากระดับคาถาที่ยิ่งใหญ่ไปจนถึงระดับต่ำสุด

คำอธิบาย

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

ตารางที่ 1: Maximized กระจายคาถาพ่อมดสำหรับแต่ละระดับมือสองจากคำตอบของ Axoren กับคำถามที่เชื่อมโยง

เครดิต

• ที่บันทึกไว้ 14 ไบต์ต้องขอบคุณเควิน Cruijssen

Python 3 , 98 ไบต์

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)

ลองออนไลน์!

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)

แก้ไข: โซลูชันที่แก้ไขเพื่อใช้กฎ D&D ที่ถูกต้อง

ถ่าน , 51 ไบต์

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

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด ใช้ระดับการสะกดคำจากน้อยไปมากเป็นสตริง คำอธิบาย:

Ｎθ

ใส่ระดับ

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

ทำการถอดรหัสวิ่งความยาวสตริงผลในสตริง0544443335 11111222233334444555566677788899999สตริงนี้จะถูกแบ่งเป็นส่วน ๆ เริ่มต้นที่ระดับ (1- ดัชนี) และสิ้นสุดที่ระดับสองเท่า (ถ้าน้อยกว่า 12) หรือ 6 + 1.5 *, ปัดขึ้นยกเว้นระดับ 19 ซึ่งถูกปัดเศษลง A 0ถูกต่อท้ายเพื่อให้แน่ใจว่าไม่มีคาถามากเกินไป

¬ΣＥＳ›ι§θκ

เปรียบเทียบระดับคาถากับซับสตริงและพิมพ์ a -หากไม่มีค่ามากเกินไป

JavaScript (ES6), 79 ไบต์

(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

ลองออนไลน์!

รหัสทดสอบ

ด้านล่างนี้คือลิงก์ไปยังโค้ดทดสอบบางอย่างที่ใช้ระดับเวทย์มนตร์เป็นอินพุตและส่งคืนอาเรย์ของระดับการสะกดสูงสุดโดยใช้ตรรกะเดียวกับฟังก์ชั่นด้านบน

ลองออนไลน์!

อย่างไร?

ตารางอ้างอิง

 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 

จำนวนคาถา

$L$$N_L$

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

ระดับการสะกดสูงสุด

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

$x$$a$

Groovyขนาด 155 ไบต์

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}

สร้าง spellbook ที่ดีที่สุดจากนั้นตรวจสอบว่า spellbook ที่ส่งผ่านไปยังวิธีการนั้นไม่ดีขึ้น

Ungolfed ด้วยประเภทโดยนัยชัดเจน:

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
}

ลองออนไลน์!