एक जादूगर की वर्तनी

Question

संपादित करें : मैंने इससे पहले D & D नहीं खेला है जब मैंने शुरू में यह प्रश्न किया था तो मैंने इसे ठीक से शोध नहीं किया था। मैं इसके लिए माफी मांगता हूं, और मैं कुछ संपादन कर रहा हूं, जो उत्तर के रूप में 5 डी नियमों के लिए यथासंभव सही रहने के लिए अमान्य हो सकते हैं। माफ़ करना।

---

हाल ही के हॉट नेटवर्क प्रश्न के एक डी एंड डी प्रशंसक को लगता है कि एक जादूगर के चुने हुए मंत्र संभावनाओं के साथ काम करते हैं - और मुझे लगता है कि हमें मदद करनी चाहिए!

परिचय

(यह सब पहले से उल्लेखित प्रश्न में वर्णित है)

एक जादूगर शुरू से दो स्तर 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]

---

यह कोड-गोल्फ है - सबसे कम बाइट्स जीतता है!

Comments

क्या हम वर्तनी सूची को छाँट सकते हैं कि हम इसे कैसे चाहते हैं?

— विस्कह

प्रत्येक वर्ग स्तर के लिए अधिकतम वर्तनी स्तर क्या है?

— नाइट्रोडॉन

@ निट्रोडॉन मैं 19 को मानता हूं?

— डॉन थाउजेंड

@ निट्रोडॉन, संभवतः यह 9 दिया गया है कि सरणी इनपुट में केवल " 1 से 9 तक के मान " हो सकते हैं, लेकिन अधिकतम वर्तनी स्तर जिसे हमें संभालने की आवश्यकता है, उसे कल्पना में अधिक स्पष्ट रूप से कहा जाना चाहिए। और यह कुछ और परीक्षण मामलों के साथ कर सकता है। अच्छी चुनौती है, अन्यथा।

— झबरा

1. "इसे 1 से 9 तक (किसी भी क्रम में) मानों के साथ पूर्णांक (वर्तनी स्तर) की एक सरणी भी लेनी चाहिए" - 10-19 के स्तर के बारे में क्या? 2. "हालांकि स्तर 4 पर वर्तनी का स्तर [2,2,3,3]संभव नहीं होगा क्योंकि इसके लिए उस स्तर के एक जादूगर की तुलना में अधिक प्रतिस्थापन की आवश्यकता होती है।" - क्या यह तथ्य नहीं है कि सूची 5 से अधिक मूलभूत कारण है, यहां लंबाई 4 है? (मुझे लगता [1,3,2,2,3]है कि स्तर 3 से जाकर स्तर 4 के लिए संभव [1,1,2(replaced),2(new)]है [1,3(replaced),2,2,3(new)]?)

— जोनाथन एलन

Answer 1

जावा (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: लिंक किए गए प्रश्न पर एक्सोरन के उत्तर से उपयोग किए गए प्रत्येक सॉसर -स्तर के लिए अधिकतम वर्तनी वितरण ।

क्रेडिट

• केविन क्रूज़सेन की बदौलत 14 बाइट्स बचाए ।

Comments

return l<1&java.util.Arrays.equals(m,new int[9]);z=0;for(int i:m)z+=i;return l+z==0;इसके बजाय हो सकता है । या अगर mअंत में मूल्य नकारात्मक नहीं हो ==0सकते हैं , तो हो सकता है <1।

— केविन क्रूज़सेन

@KevinCruijssen धन्यवाद! और सूची में बहुत सारे मंत्रों के साथ एक बग को ठीक करने के लिए उस कमरे में।

— ओलिवियर ग्रेगोइरे

आह, for(int i:m)l|=i;और भी चालाक है! अच्छा है।

— केविन क्रूज़सेन

मुझे यकीन है कि अंतिम दो छोरों को जोड़ा जा सकता है, मुझे अभी नहीं पता कि अभी कैसे।

— ओलिवियर ग्रेजायर

@CameronAavik आपने संभवत: आरोही क्रम ( new int[]{5,6,6,6,7,7,7,8,8,8,9,9,9,9,9}) के साथ इसे पास कर दिया है । यदि मैं उन्हें नीचे उतरता हूं ( new int[]{9,9,9,9,9,8,8,8,7,7,7,6,6,6,5}जैसा कि मैंने गोल्फ के नीचे लिखी गई इनपुट आवश्यकता में लिखा है), यह काम करता है। मैंने परीक्षण मामले को यह दिखाने के लिए जोड़ा कि यह वास्तव में काम करता है।

— ओलिवियर ग्रेगोइरे

Answer 2

पायथन 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)

संपादित करें: सही डी एंड डी नियमों का उपयोग करने के लिए सही समाधान

Comments

I + 1'ed, हालांकि print(v(20, [6,6,6,6,7,7,7,8,8,8,9,9,9,9,9])) # Falseप्रिंट सच है। इसे झूठा छापना चाहिए।

— ओलिवियर ग्रेजायर 12

@ OlivierGrégoire मैं ओपी के नियमों का उपयोग कर रहा हूं कि आपूर्ति कोड में कौन से कौशल स्तर मान्य हैं। पोस्ट के निचले भाग पर नोट देखें जो वास्तविक डीएनडी नियमों का उपयोग करने के लिए संशोधन दिखाता है।

— कैमरून Aavik

मेरी गलती है। माफ़ करना। उस बदलाव के साथ आउटपुट सही है।

— ओलिवियर ग्रेगोइरे

खैर, यह तय हो गया: यह डी एंड डी नियम है जिसे लागू करने की आवश्यकता है, न कि min(9,n-1)एक।

— ओलिवियर ग्रेगोइरे

Answer 3

चारकोल , 51 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। एक स्ट्रिंग के रूप में आरोही क्रम में वर्तनी का स्तर लेता है। स्पष्टीकरण:

Ｎθ

स्तर इनपुट करें।

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

स्ट्रिंग में 0544443335जिसके परिणामस्वरूप रन-लंबाई डिकोडिंग निष्पादित करें 11111222233334444555566677788899999। यह स्ट्रिंग तब स्तर (1-अनुक्रमित) पर शुरू और दोगुनी स्तर (यदि कम से कम 12) या 6 + 1.5 * पर समाप्त हो जाती है, तो गोल है, स्तर 19 को छोड़कर, जो गोल है। ए 0यह सुनिश्चित करने के लिए प्रत्यय है कि बहुत सारे मंत्र नहीं हैं।

¬ΣＥＳ›ι§θκ

सबस्ट्रिंग के खिलाफ वर्तनी के स्तर की तुलना करें और -उनमें से कोई भी अत्यधिक होने पर प्रिंट करता है ।

Comments

मुझे लगता है कि यह उन लंबाई से कम के लिए विफल रहता है जितना उन्हें होना चाहिए, जैसा कि मुझे लगता है कि सूचीबद्ध नहीं स्तरों पर वर्तनी अधिग्रहण अनिवार्य है; मैंने हालांकि स्पष्टीकरण मांगा है।

— जोनाथन एलन

ऐसा लगता है कि 11113स्तर के लिए असफल हो रहा है 4जो बिना वैकल्पिक उन्नयन का परिणाम है, 12 स्तर पर ले जा रहा है, 13 के स्तर पर और 34. स्तर पर।

— जोनाथन एलन

@JonathanAllan आपका अधिकतम वर्तनी स्तर आपके चरित्र स्तर के आधे हिस्से की छत है (या 9, जैसा कि अधिकतम संभव है)। शायद सवाल यह स्पष्ट नहीं किया।

— नील

(मूल रूप से मैंने लिंक किए गए प्रश्न के उत्तर का अनुसरण किया है कि संभावित वर्तनी स्तर क्या हैं।)

— नील

मैं दो विशिष्टताओं को समझने और समेटने की कोशिश नहीं करना चाहता, ओपी ने टिप्पणियों में न्यूनतम (9, एन -1) की पुष्टि की है। शायद यह वहाँ क्वेरी ...

— जोनाथन एलन

Answer 4

जावास्क्रिप्ट (ईएस 6), 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$

Answer 5

ग्रूवी , 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}

सर्वोत्तम संभव वर्तनीपुस्तिका बनाता है, फिर जाँचता है कि वर्तनी पुस्तक विधि में उत्तीर्ण नहीं है।

अस्पष्ट, अंतर्निहित प्रकार स्पष्ट किए गए:

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
}

इसे ऑनलाइन आज़माएं!