निंजा की 9 मौतें

Question

चैट में इस बातचीत से प्रेरित ।

इस चुनौती में आपका लक्ष्य एक निंजा का अनुकरण करना है और गिनना है कि उसने कितनी मौतें छोड़ी हैं।

चश्मा

आप निंजा 9 मौतों के साथ बाहर निकलते हैं। उन्हें इनपुट के रूप में एक अभिन्न शुरुआती स्वास्थ्य भी मिलता है।

फिर, वह इनपुट के रूप में अपने जीवन की घटनाओं की एक सूची लेता है जो उसके स्वास्थ्य को बदल देता है। ये नकारात्मक, सकारात्मक या शून्य पूर्णांक हो सकते हैं।

किसी भी बिंदु पर, यदि उसका स्वास्थ्य शून्य या उससे कम पर पहुंचता है, तो वह एक जीवन खो देता है और उसका स्वास्थ्य प्रारंभिक स्वास्थ्य में वापस चला जाता है।

आपके कार्यक्रम को उसके द्वारा छोड़ी गई मौतों की संख्या की रिपोर्ट करनी चाहिए। यदि उसके पास शून्य या उससे कम शेष है, तो आपको deadइसके बजाय आउटपुट करना चाहिए ।

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

परीक्षण के मामलों

3, [] -> 9
100, [-20, 5, -50, 15, -30, -30, 10] -> 8
10, [-10, -10, -10, -10] -> 5
10, [-10, -10, -10, -10, -10, -10, -10, -10, -10] -> dead
0, [] -> dead
0, [1] -> dead
100, [10, -100] -> 9

Comments

वाह!!! मेरा चैट पोस्ट जुड़ा हुआ है !!! : P

— R

लगता है कि मैं मुसीबत में हूँ ...

— NinjaBearMonkey

तो घटनाओं का क्रम "मरना है अगर <= 0, एक संख्या पढ़ें, कुल में जोड़ें, दोहराएं"?

— lirtosiast

@ThomasKwa हाँ, लेकिन मरना कई बार हो सकता है

— माल्टीसेन

क्या निनजा फिर से समय की तरह पुनर्जीवित हो सकता है? कृप्या?

— अश्विन गुप्ता

Answer 1

जेली , 30 28 26 बाइट्स

»0o⁴+
;@ñ\<1S_9«0N“dead”×?

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

यह काम किस प्रकार करता है

;@ñ\<1S_9«0N“dead”×?  Main link. Input: e (events), h (initial health)

;@                    Prepend h to e.
  ñ\                  Reduce the resulting array by the next, dyadic link.
                      This returns the array of intermediate results.
    <1                Check each intermediate value for non-positivity.
      S               Sum. This calculates the number of event deaths.
       _9             Subtract 9 from the result.
         «0           Take the minimum of the result and 0. This yields 0 if no
                      lives are left, the negated amount of lives otherwise.
                   ?  Conditional:
                  ×     If the product of the minimum and h is non-zero:
           N              Return the negated minimum.
            “dead”      Else, return "dead".


»0o⁴+                 Dyadic helper link. Arguments: x, y

»0                    Take the maximum of x and 0.
                      This yields x if x > 0 and 0 otherwise.
  o⁴                  Take the logical OR of the result and the second input (h).
    +                 Take the sum of the result and y.

Comments

¯_ (¯) _ / ¯ डेनिस जीतता है

— डाउनरेप_नेशन

Answer 2

जाप, 40 39 32 बाइट्स

U¬©(9-Vf@T=X+(T¬²ªU)<1} l)¬²ª`Ü%

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

यह काम किस प्रकार करता है

गोल्फ को यह कल रात का प्रयास करते समय (एक कंप्यूटर से दूर, कम नहीं), मैं एक दिलचस्प प्रतिस्थापन भर के लिए भाग गया >0: ¬। संख्याओं पर, यह वर्गमूल लेता है, जो NaNनकारात्मक संख्याओं के लिए लौटता है । NaNमिथ्या है, इसलिए यह ठीक उसी तरह से सच है / जैसा कि मिथ्या है >0।

इस ट्रिक को थोड़ा आगे बढ़ाते हुए, हम T से U iff >=0को केवल पाँच बाइट्स में रीसेट कर सकते हैं T¬²ªU:। यह कैसे काम करता है? चलो एक नज़र डालते हैं:

T    ¬      ²       ªU
     sqrt   square  if falsy, set to U (JS's || operator)
4    2      4       4
7   ~2.646  7       7
0    0      0       U
-4   NaN    NaN     U
-7   NaN    NaN     U

जैसा कि आप देख सकते हैं, अगर नकारात्मक है तो T¬²रिटर्न ; अन्यथा, यह वापस आ जाता है । चूंकि और दोनों मिथ्या हैं, यह निंजा के स्वास्थ्य को रीसेट करने का एक आसान तरीका प्रदान करता है । इस तरकीब का उपयोग निंजा के बचे हुए जीवन को वापस करने के लिए भी किया जाता है यदि वह संख्या सकारात्मक है, या यदि नकारात्मक है।NaNTTNaN0ªU"dead"

यह सब एक साथ रखना:

           // Implicit: U = starting health, V = events, T = 0
U©        // If U is positive,
Vf@     }  // Filter out the items X in V that return truthily from this function:
 T=X+      //  Set T to X plus
 (T¬²ªU)   //   If T is positive, T; otherwise, U.
           //  This keeps a running total of the ninja's health, resetting upon death.
 <1        //  Return (T < 1).
9-    l)   // Take the length of the resulting array and subtract from 9.
           // This returns the number of lives the ninja has left.
¬²         // If the result is negative, set it to NaN.
ª`Ü%       // If the result of EITHER of the two parts above is falsy, return "dead".
           //  (`Ü%` is "dead" compressed.)
           // Otherwise, return the result of the middle part (lives left).
           // Implicit: output last expression

यदि इनपुट गैर-नकारात्मक होने की गारंटी है, या सकारात्मक भी है, तो हम 1 या 4 बाइट्स का गोल्फ कर सकते हैं:

U©(9-Vf@T=X+(T¬²ªU)<1} l)¬²ª`Ü%  // U is non-negative
9-Vf@T=X+(T¬²ªU)<1} l)¬²ª`Ü%     // U is positive

Answer 3

जावास्क्रिप्ट ईएस 6, 62 60 58 बाइट्स

सहेजे गए 4 बाइट्स @ETHproductions की बदौलत

(a,b,d=9,l=a)=>b.map(i=>l=l+i<1?d--&&a:l+i,a)|d<1?"dead":d

इसे ऑनलाइन आज़माएं (सभी ब्राउज़र काम करते हैं)

व्याख्या

(a,b,    // a = 1st input, b = 2nd input
 d=9)=>  // Lives counter

  (b.reduce((l,i)=>     // Loop through all the health changes
    l+i<1                 // If (health + health change) < 1
    ?(d--,a)              // Decrease life, reset health
    :l+i                  // Return new health
  ,a)                   // Sets starting health to `a`
  ,d<1?        // Lives is less than 1
   "dead":d);  // Output "dead" otherwise lives left

Comments

चाहेंगे d--&&aकाम करते हैं, या b.reduce(...)&&d<1?"dead":d?

— 21

mapreduceअधिकांश परिदृश्यों में धड़कता है: (a,b,d=9,l=a)=>b.map(i=>l=l+i<1?d--&&a:l+i)&&d<1?"dead":d57.

— ETHproductions

@ETHproductions धन्यवाद, मुझे नहीं लगता कि रिटर्न की .reduce(...)&&वजह से यह काम करेगा, यह काम नहीं करेगा। .reduce0

— डाउनगेट

(a,b,d=9,l=a)=>b.map(i=>l=l+i<1?d--&&a:l+i,a)|d<1?"dead":dइसके बजाय काम करेंगे ?

— ETHproductions

Answer 4

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

q~_@{+_1<{W$}&}/](\,_A<@*A@-"dead"?

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

Answer 5

हास्केल, 81 77 75 बाइट्स

p l i h a|l<1="dead"|i<1=p(l-1)h h a|[]<-a=show l|x:y<-a=p l(i+x)h y
p 10 0

उपयोग का उदाहरण: p 10 0 100 [-20, 5, -50, 15, -30, -30, 10]->"8"

Answer 6

पायथ, ३२

 u+?>GZG&=hZQH+E0Q?&Q<Z9-9Z"dead

ध्यान दें कि एक अग्रणी स्थान है। यह शायद सबसे अच्छा तरीका नहीं है, लेकिन यह पहली बात थी जो दिमाग में आई। यह निन्जा के स्वास्थ्य के लिए मूल्यों को जोड़कर और शून्य से नीचे जाने पर स्वास्थ्य को रीसेट करने और स्वास्थ्य को रीसेट करने पर इनपुट में कमी करता है। हम सूची में अंतिम स्थान पर शून्य को जोड़ते हैं यदि अंतिम परिवर्तन निंजा को मारता है, और फिर निंजा को मरा हुआ है या नहीं यह देखने के लिए बस कुछ जाँच करें। शून्य प्रारंभिक स्वास्थ्य मामला हार्ड कोडित है।

परीक्षण सूट

Answer 7

MATL, 32

9yi"@+t0>~?x1-y]]g*wxt0>~?x'dead'

व्याख्या

9        # push 9
y        # duplicate 2nd value to top (there is none -> get it from input first)
i        # get input and push it

स्टैक अब इस तरह दिखता है (इनपुट के लिए 100, [-20, 5, -50, 15, -30, -30, 10]):

100        9        100        [-20, 5, -50, 15, -30, -30, 10]

reload   deaths    health
value    left

सरणी और लूप पॉप करें

"            ]    # loop
 @+               # add to health
   t0>~?    ]     # if health is zero or less
        x1-y      # delete health counter, decrement life counter, reload health

यदि स्वास्थ्य शून्य है, तो मृत्यु काउंटर को शून्य पर सेट करें। के लिए विशेष मामले से निपटने के initial health = 0।

g        # health to bool
*        # multiply with death counter

स्टैक से पुनः लोड मान हटाएं

wx

यदि मृत्यु काउंटर शून्य या उससे कम है, तो इसे हटा दें और इसके बजाय 'मृत' प्रिंट करें।

t0>~?x'dead'

Answer 8

टीस्क्रिप्ट , 36 34 31 बाइट्स

yR#l+i<1?e─·x:l+i,x);e≥0?e:D`Ü%

मेरे जावास्क्रिप्ट उत्तर के समान। अंतिम 4 वर्ण स्ट्रिंग "डेड" का अपघटन है।

TeaScript की ऑनलाइन दुभाषिया सरणी इनपुट का समर्थन नहीं करती है, इसलिए आपको कंसोल खोलने की आवश्यकता है, और इसे टाइप करके चलाएं:

TeaScript( `yR#l+i<1?(e─,x):l+i,x);─e>0?e:D\`Ü%` ,[
  10, [-10, -10, -10, -10]
],{},TEASCRIPT_PROPS);

व्याख्या

      // Implicit: x = 1st input, y = 2nd input
yR#   // Reduce over 2nd input
  l+i<1?  // If pending health is less then 1
  (e─,x): // then, decrease life counter, reset health
  l+i     // else, modify health
,x);  // Set starting health
─e>0? // Ninja is alive?
e:    // Output lives left
D`Ü%  // Decompress and output "dead"

Answer 9

पायथन 2.7, 82 66 55 106 बाइट्स

@ -16 बाइट्स के लिए @RikerW को धन्यवाद। :(

-11 बाइट्स के लिए @Maltysen का शुक्रिया। :(

i=input;h=[i()]*9;d=i()
if 0==h[0]:print'dead';exit()
for x in d:
 h[0]+=x
 if h[0]<=0:h=h[1:]
y=len(h)
print['dead',y][y!=0]

पहले प्रकार का स्वास्थ्य, फिर दर्ज करें, फिर सूची के रूप में घटनाएं।

Answer 10

C # 207

class P{static void Main(string[]a){int h=int.Parse(a[0]),H=h,l=9,i=1;if(a.Length!=1){for(;i<a.Length;i++){H+=int.Parse(a[i]);if(H<=0){l--;H=h;}}}System.Console.Write(h==0?"dead":l<=0?"dead":l.ToString());}}

तर्क धारा के माध्यम से इनपुट लेता है। पहला तर्क स्वास्थ्य की मात्रा है और बाकी सभी घटनाओं की सूची है।

पठनीय / अधूरा संस्करण

class Program
{
    static void Main(string[]a)
    {
        int health = int.Parse(a[0]);
        int Health = health;
        int lives = 9;

        if(a.Length!=1)
        {
            for (int i = 1;i < a.Length;i++)
            {
                Health += int.Parse(a[i]);
                if (Health <= 0)
                {
                    lives--;
                    Health = health;
                }
            }
        }

        System.Console.Write(health == 0 ? "dead" : lives <= 0 ? "dead" : lives.ToString());
    }
}

उदाहरण:

• CSharp.exe 3 => 9

• CSharp.exe 100 -20 5 -50 15 -30 -30 10 => 8

(Psst।) CSharp.exe एक उदाहरण के रूप में प्रयोग किया जाता है। आपको इस तरह से वास्तविकता में कॉल करना होगा: [program_name.exe] तर्क, वर्ग कोष्ठक के बिना।