डी एंड डी प्वाइंट खरीद लागत

20

डंगऑन और ड्रेगन चरित्र बनाते समय , क्षमता स्कोर को रोल करने का एक विकल्प उन्हें एक पावर बजट के भीतर खरीदना होता है। उच्च क्षमता स्कोर में अधिक अंक खर्च होते हैं, विशेष रूप से ऊपरी छोर की ओर: 8 का स्कोर मुफ़्त है, और 1 अंक 1 अंक बढ़ाकर 15 या 16 लागत 2 अंक को छोड़कर, और 17 या 18 तक बढ़ाकर 3 अंक हो जाते हैं।

+-------+------+
| Score | Cost |
+-------+------+
|     8 |    0 |
|     9 |    1 |
|    10 |    2 |
|    11 |    3 |
|    12 |    4 |
|    13 |    5 |
|    14 |    6 |
|    15 |    8 |
|    16 |   10 |
|    17 |   13 |
|    18 |   16 |
+-------+------+

सूची के रूप में:

[(8, 0), (9, 1), (10, 2), (11, 3), (12, 4), (13, 5), (14, 6), (15, 8), (16, 10), (17, 13), (18, 16)]

सभी छह क्षमता स्कोर के लिए पॉइंट बाय कॉस्ट को अभिव्यक्त किया गया है।

Ability scores: 16   17   8  13   8  12
Point buy cost: 10 + 13 + 0 + 5 + 0 + 4  = 32

छह क्षमता स्कोर को देखते हुए, प्रत्येक 8 18 के माध्यम से, कुल बिंदु खरीद लागत का उत्पादन करता है। सबसे कम बाइट्स जीतता है।

कोड स्निपेट दिखाएं

code-golf  arithmetic 
— XNOR
स्रोत
2
Äम यह सिर्फ मुझे है या दिया गया चालान गायब है? 0o
— Zaibis
1
@Zaibis यकीन नहीं है कि आप क्या मतलब है। मैंने "सबसे कम बाइट्स जीत" में रखा - क्या आपका मतलब यह था?
— xnor
tmp blah blah कहने के लिए: हाँ
— ज़ैबिस

जवाबों:

11

जावास्क्रिप्ट (ईएस 7), 44 42 40 बाइट्स

पार किया 44 अभी भी नियमित है 44 :(

a=>a.map(s=>t+=s-9-~((s-14)**1.3),t=0)|t

2 बाइट बचाने के लिए @apsillers को धन्यवाद !

व्याख्या

दिलचस्प हिस्सा है -1-~((s-14)**1.3)। (s-14)**1.3पैदा करता है 1, 2, 4और 6मूल्यों के लिए 15 - 18। कोई भी संख्या जो 15त्रुटि के कारण से कम है क्योंकि घातीय घातांक के जावास्क्रिप्ट कार्यान्वयन नकारात्मक मानों पर काम नहीं कर सकता है। मूल रूप से, किसी भी मूल्य के s < 15कारण यह वापस आ जाता है NaN, तो -1-~क्या यह एक संख्या ( 0) में डालना है ।

a=>                       // a = input scores as an array of numbers
  a.map(s=>               // for each passed score
    t+=                   // add to the total
      s-9                 // point value = s - 8 (-1 used for next line)
      -~((s-14)**1.3),    // add extra points for scores 15 - 18
    t=0                   // t = total points (this happens BEFORE the map call)
  )
  |t                      // return the total points

ईएस 6 सॉल्यूशन (42 बाइट्स)

a=>a.map(s=>t+=s-9-~[1,2,4,6][s-15],t=0)|t

परीक्षा

यह परीक्षण Math.powघातांक ऑपरेटर ( **) के बजाय उपयोग करता है ताकि यह किसी भी मानक ब्राउज़र में चल सके।

कोड स्निपेट दिखाएं

— user81655
स्रोत
एक और बाइट: के |tबजाय का उपयोग करें &&t। ECMAScript आपरेशनToInt32 हमेशा के परिणाम विवश होगा mapयहाँ करने के लिए 0, क्योंकि बहु तत्व सरणियों हमेशा जाएगा ToNumberकरने के लिए -ify NaN। (यह एक समस्या होगी यदि युक्ति इनपुट के रूप में एकल-तत्व सरणियों की अनुमति देती है, लेकिन इसके लिए 6 तत्वों की आवश्यकता होती है।)
— अप्सिलर्स
@apsillers ऊह, यह एक अच्छी टिप है! धन्यवाद
— user81655
8

सीजेएम, 18 बाइट्स

l~[8EG]ff-:~0fe>:+

या

l~[8EG]m*::m0fe>:+

इसका परीक्षण यहां करें।

व्याख्या

विचार बिंदु लागत को तीन घटकों में विघटित करता है:

 Score: 8  9 10 11 12 13 14 15 16 17 18
        0  1  2  3  4  5  6  7  8  9 10
        0  0  0  0  0  0  0  1  2  3  4
        0  0  0  0  0  0  0  0  0  1  2
       --------------------------------
 Cost:  0  1  2  3  4  5  6  8 10 13 16

सभी तीन घटकों को एक एकल घटाव के माध्यम से गणना की जा सकती है और परिणाम को गैर-नकारात्मक मानों तक सीमित किया जा सकता है।

l~    e# Read and evaluate input.
[8EG] e# Push [8 14 16].
ff-   e# For each pair from the two lists, subtract one from the other. 
:~    e# Flatten the result.
0fe>  e# Clamp each difference to non-negative values.
:+    e# Sum them all up.
— मार्टिन एंडर
स्रोत
8

अजगर, 14 बाइट्स

s>#0-M*Q+14yB8

परीक्षण सूट

यह मार्टिन ब्युटनर के रूप में गणना के समान मूलभूत साधनों का उपयोग करता है:

max(n-8, 0) + max(n-14, 0) + max(n-16, 0)

कहा जा रहा है, गणना के साधन बहुत अलग हैं। घटाना करने के लिए संख्याओं की सूची उत्पन्न करने के लिए, मैं अभिव्यक्ति का उपयोग करता हूं +14yB8। yB8का अर्थ है "फ़ंक्शन y पर Bifurcate 8"। y संख्या को दोगुना करता है, इसलिए यह देता है [8, 16]। फिर, हम 14 को जोड़ते हैं, सूची देते हैं[14, 8, 16] ।

अगला, हम कार्टेशियन उत्पाद को इनपुट के साथ लेते हैं और प्रत्येक जोड़ी के मूल्यों को घटाते हैं।

अगला, अधिकतमकरण ऑपरेशन करें, हम केवल सकारात्मक मानों के लिए फ़िल्टर करते हैं, और शेष राशि का योग करते हैं।

— isaacg
स्रोत
4

Samau , 19 बाइट्स

निश्चित नहीं है कि प्रश्न मेरी नई भाषा के अंतिम वचन के बाद पोस्ट किया गया है या नहीं । वे दोनों 2 घंटे पहले के हैं। लेकिन इससे पहले यहां इस्तेमाल की जाने वाली सभी सुविधाओं को जोड़ा गया था।

▐[8 14 16]`-o;0>*ΣΣ

Samau CP737 को अपने डिफ़ॉल्ट चरित्र एन्कोडिंग के रूप में उपयोग करता है ।

▐[8 14 16]`-o;0>*ΣΣ
▐                      read a list of numbers
 [8 14 16]             push [8 14 16]
          `-           push the function [-]
            o          outer product
             ;         duplicate
              0>       for each element, test if it's larger than 0
                *      times
                 ΣΣ    take the sum twice because it's a 2d array
— alephalpha
स्रोत
0

पॉवरशेल, 48 बाइट्स

$args|%{$t+=$_-8+@{15=1;16=2;17=4;18=10}[$_]};$t

(बहुत यकीन है कि यह इष्टतम नहीं है।)

इनपुट कमांड-लाइन तर्कों को लेता है और उन्हें एक लूप में पाइप करता है |%{...}। प्रत्येक पुनरावृत्ति, हम $t+=वर्तमान संख्या माइनस 8 के साथ अपने कुल में वृद्धि $_-8करते हैं और अधिक महंगे मूल्यों के लिए हैशटेबल में अनुक्रमित करने का परिणाम है @{...}[$_]। तब हम $tअंत में उत्पादन करते हैं।

— AdmBorkBork
स्रोत
0

(++) ऑक्सी ++, 248 बाइट्स (62 अक्षर)

🐀👉🌑👺🐁👉🌑👺😂🐀🐟🌗😂🐂👉😷😺😺😷👺🐁👉🐁👏🐂🙌🌙👏🌜🐂🐳🌒🌕🌛👥🌜🐂🙌🌒🌕🌛👏🌜🐂🐳🌒🌗🌛👥🌜🐂🙌🌒🌗🌛👺🐀👍😂👄🐁👄

भाषा मैं काम कर रहा हूँ। यहां कोड में पेस्ट करें ।

— geokavel
स्रोत
मेरा ब्राउज़र इनमें से केवल 7 अक्षर प्रदर्शित कर सकता है।
— इसहाक
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.