편집 : 나는 전에 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]

---

이것은 코드 골프입니다 -가장 적은 바이트가 이깁니다!

자바 (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 : 링크 된 질문에 대한 Axoren의 답변에서 사용 된 각 마법사 레벨에 대한 극대화 된 주문 분포 .

크레딧

• Kevin Cruijssen 덕분에 14 바이트를 절약했습니다 .

파이썬 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)

온라인으로 사용해보십시오!

언 골프 드 :

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 색인)에서 시작하여 2 배 레벨 (12보다 작은 경우) 또는 6 + 1.5 *에서 끝나고 (반올림 된 레벨 19는 제외) 반올림됩니다. 0주문이 너무 많지 않도록 A 를 접미사로 사용합니다.

¬ΣＥＳ›ι§θκ

서브 스트링과 스펠 레벨을 비교하고 -그 중 어느 것도 초과하지 않으면 a를 인쇄합니다 .

자바 스크립트 (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$

$$N_L=\begin{cases} L+1&\text{if }L<12\\ \lfloor(L+13)/2\rfloor&\text{if }12\le L\le 16\\ 15&\text{if }L>16 \end{cases}$$

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

최대 주문 레벨

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

$$M_{L,i}=\begin{cases} \lfloor(L+i+2)/4\rfloor&\text{if }L+i<25\\ \lfloor(L+i+4)/4\rfloor&\text{if }25\le L+i\le 30\\ 9&\text{if }L+i>30 \end{cases}$$

$x$$a$

그루비 , 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}

가능한 최고의 철자 책을 생성 한 다음, 메소드에 전달 된 철자 장이 더 나은지 점검합니다.

암시 적 유형을 명시 적으로 사용하여 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
}

온라인으로 사용해보십시오!