सांता को उपहार देने के लिए कितनी कल्पित वस्तुएँ चाहिए?

23

सांता को यह निर्धारित करने में मदद की जरूरत है कि प्रत्येक घर को उपहार देने में उसे कितनी कल्पित मदद की जरूरत होगी।

कोयला प्रस्तुत करने की तुलना में काफी भारी है, इसलिए संता को घर के हर शरारती व्यक्ति के लिए तीन कल्पित बौनों की आवश्यकता होगी। सांटा को प्रस्तुत करने में मदद करने के लिए केवल दो कल्पित बौनों की आवश्यकता होती है।

संता के नक्शे पर, एक घर को एक द्वारा दर्शाया गया है *, और प्रत्येक घर को एक से विभाजित किया गया है +।

घर के दोनों ओर एक नंबर होगा - एक बाईं ओर, जो घर में शरारती लोगों की संख्या का प्रतिनिधित्व करता है, और एक दाईं ओर घर में अच्छे लोगों की संख्या का प्रतिनिधित्व करता है। यदि एक तरफ कोई संख्या नहीं है, तो इसे 0 के रूप में व्याख्या किया गया है।

सांता उन लोगों की यात्रा नहीं करते हैं जो क्रिसमस की भावना में नहीं हैं (वे कोयले के लायक भी नहीं हैं), इसलिए कभी-कभी, एक घर में इसके दोनों ओर एक नंबर नहीं हो सकता है। इस मामले में, संता को किसी भी कल्पित बौने से मदद की ज़रूरत नहीं है

उदाहरण के लिए, संता के नक्शे में से एक इस तरह दिख सकता है

1*3+2*2+1*+*2

पहले घर में 1 शरारती और 3 अच्छे हैं, संता को नौ बछड़ों की आवश्यकता होगी । दूसरे में, 2 शरारती और 2 अच्छे हैं, संता को दस कल्पित बौनों की आवश्यकता होगी । तीसरे घर में 1 शरारती और 0 अच्छा है, संता को तीन बछड़ों की आवश्यकता होगी , और आखिरी घर में 0 शरारती और 2 अच्छे हैं, संता को चार बछड़ों की आवश्यकता होगी ।

यह संता के नक्शे में से एक का एक सरलीकृत संस्करण है, हालांकि। आम तौर पर, संता के नक्शे में कई लाइनें होती हैं, और उनकी सूची में बेहतर फिट होने के लिए एक चौकोर आकार में होते हैं। एक सामान्य नक्शा कुछ इस तरह दिख सकता है ( \nप्रत्येक पंक्ति के अंत में)

1*2+*+*4+1*
2*4+3*+1*6+*
*+*+4*2+1*1
*4+*3+1*+2*3
3*10+2*+*5+*

इस नक्शे में, संता की जरूरत है ((1 + 0 + 0 + 1 + 2 + 3 + 1 + 0 + 0 + 0 + 4 + 1 + 0 + 0 + 1 + 2 + 3 + 2 + 0 + 0) * 3) + ((2 + 0 + 4 + 0 + 4 + 0 + 6 + 0 + 0 + 0 + 2 + 1 + 4 + 3 + 0 + 3 + 10 + 0 + 5 + 0) * 2)= 151 कल्पित बौने

चुनौती

संता को यह निर्धारित करने में मदद करें कि उसे प्रत्येक घर तक सामान पहुँचाने के लिए कितनी कल्पित ज़रूरत है!

मकानों

  • एक घर एक द्वारा प्रतिनिधित्व किया है *
  • मकान बंट जाते हैं +
  • घर के बाईं ओर की संख्या शरारती लोगों की संख्या का प्रतीक है (संख्या का मतलब 0 नहीं है)
  • दाईं ओर संख्या अच्छे लोगों की संख्या का प्रतीक है (संख्या का मतलब 0 नहीं है)
  • \nइनपुट में न्यूलाइन्स ( ) हो सकते हैं , जिन्हें स्प्लिट के रूप में भी हैंडल किया जाना चाहिए

कल्पित बौने

  • संता को शरारती लोगों के लिए तीन बछड़ों की मदद चाहिए (कोयले की तुलना में बहुत भारी है)
  • सांता को अच्छे लोगों के लिए दो कल्पित बौनों की मदद चाहिए
  • यदि दोनों ओर कोई संख्या नहीं है, तो संता उस घर का दौरा नहीं करेगा, और उसके बाद किसी भी कल्पित बौने की आवश्यकता नहीं है

क्या करें

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

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

1*1 => 5
1*2 => 7
2*1 => 8
1* => 3
*1 => 2
* => 0

1*1+1*1 => 10
1*2+2*1 => 15
1*+*1 => 5
1*1+*+1*1 => 10
*+*+*+* => 0

नियम

  • इनपुट को किसी फ़ंक्शन में तर्क के रूप में लिया जा सकता है, या STDIN या समकक्ष से
  • आउटपुट या तो फ़ंक्शन का रिटर्न मान हो सकता है, या STDOUT या समकक्ष के लिए मुद्रित किया जा सकता है
  • इनपुट केवल नंबर, शामिल होंगे +, *और नई-पंक्तियों\n
  • आउटपुट केवल कुल योग की संख्या होनी चाहिए जिसे सांता को क्रिसमस पर वितरित करने के लिए मदद चाहिए
  • मानक खामियां लागू होती हैं

स्कोरिंग

सांता की बेपहियों की गाड़ी उपहारों से भरी हुई है, जिससे उसे कोड चलाने के लिए कम जगह मिल रही है, इसलिए उसे सबसे कम कोड की आवश्यकता होती है, (चिंता न करें अगर यह समझ में नहीं आता है। यदि आप सांता के तर्क पर सवाल उठाते हैं तो आप शरारती सूची पर समाप्त हो जाएंगे। )। सांता कॉर्क्ट तर्क के कारण, बाइट्स में सबसे कम सबमिशन जीतता है!

लीडरबोर्ड

यह एक स्टैक स्निपेट है जो लीडरबोर्ड और भाषा द्वारा विजेताओं के अवलोकन दोनों को उत्पन्न करता है।

अपने उत्तर को सुनिश्चित करने के लिए, कृपया निम्नलिखित मार्कडाउन टेम्पलेट का उपयोग करके अपना उत्तर शीर्षक से शुरू करें

## Language Name, N bytes

जहाँ N आकार में है, बाइट्स में, आपके सबमिशन का

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (उदाहरण के लिए, पुराने स्कोर के माध्यम से, या बाइट काउंट में झंडे सहित), तो बस यह सुनिश्चित कर लें कि वास्तविक शीर्षक आपके हेडर में अंतिम संख्या है।

## Language Name, <s>K</s> X + 2 = N bytes

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

code-golf  string 
— Jojodmo
स्रोत
1
मुझे आश्चर्य है, जैसा कि सांता किसी भी घर में रुक जाएगा, क्या उसे max(naughty) + max(nice)पूरे मार्ग के लिए अधिकतम बछड़ों की आवश्यकता नहीं होगी ? मैंने सोचा कि उसके साथ उड़ने वाले बछड़ों का एक झुंड है, लेकिन हो सकता है कि आपको उस पर अंदरूनी जानकारी हो और मुझे इस साल करीब आने की जरूरत है। :)
— 8
8
@insertusernamehere मैं वर्तमान में सांता इंक में काम करता हूं और मैं आपको बता सकता हूं कि हमारा इन्फ्रास्ट्रक्चर एक भारी async फैशन में काम करता है। वह अपने संसाधनों को भूखा नहीं रखना चाहता है, इसलिए हम आवश्यकतानुसार कई श्रमिकों को आवंटित करते हैं। यदि हमें एक अतिरिक्त ईएलएफ की आवश्यकता होती है, तो हम कुछ सेकंड में एक संकलन कर सकते हैं hello-world.c। वर्कर्स एल्व्स को उत्सुकता से लक्ष्य के लिए आवंटित किया जाता है जैसा कि जोजोडो ने कहा (मुझे यकीन है कि मैं जोजोड्मो को जानता हूं, वह हमारा सिसमम होना चाहिए) और फिर यह सूचित करने के लिए कॉलबैक का उपयोग करें कि स्लीपर पूल में पुन: स्थापित होने का समय है या जब बच्चा उन्हें देखता है।
— स्टेफानो सैनफिलिपो
2
@StefanoSanfilippo आह, मैं देखता हूं। इस वर्गीकृत जानकारी की सभी विस्तृत जानकारी के लिए धन्यवाद। और मेरी क्रिसमस। :)
— इन्सुरेसेनमेम्बर
यह पूरी तरह से समझ में आता है। सांता को सबसे छोटे कोड की आवश्यकता होती है क्योंकि वह एक प्रिंटर के साथ कोड के हर चरित्र को प्रिंट करता है और फिर उन्हें निष्पादित करने से पहले उन्हें अपने बेपहियों की गाड़ी पर रख देता है।
— A

जवाबों:

2

पायथ, 21 बाइट्स

ssMs*VCcR\*scR\+.z_S3

बहु-पंक्ति उदाहरण

सिंगल-लाइन टेस्ट सूट

ssMs*VCcR\*scR\+.z_S3
                .z        Take a input, as a list of lines.
            cR\+          Chop each line on '+'.
           s              Flatten into list of strings.
       cR\*               Chop each line on '*'.
      C                   Transpose, into a list of naughty and nice.
    *V            _S3     Vectorized multiplication with [3, 2, 1]. This replicates
                          the naughty list 3 times and the nice list 2 times.
   s                      Flatten.
 sM                       Convert each string to an int.
s                         Sum.
— isaacg
स्रोत
गंभीरता से ... वहाँ कुछ भी नहीं है 30 बाइट्स में पायथ नहीं कर सकता है?
— जोजोडमो
2
@ जोजोमो नहीं तो मैं इसकी मदद कर सकता हूं ...
— isaacg
13

जावास्क्रिप्ट (ईएस 6), 52 बाइट्स

s=>eval(s.replace(/\D|$/g,m=>`.0*${m=="*"?3:2}+`)+0)

व्याख्या

इनपुट को एक मान्य जावास्क्रिप्ट स्टेटमेंट में परिवर्तित करता है। सभी के *साथ .0*3+और अन्य सभी (गैर-अंक) प्रतीकों के साथ प्रतिस्थापित करता है .0*2+। उदाहरण के लिए 8*9+*10बन जाता है 8.0*3+9.0*2+.0*3+10। अंत में यह .0*2अंतिम अच्छी गिनती के लिए अंत में जोड़ता है। यह काम करता है क्योंकि n.0= nऔर .0= 0।

s=>
  eval(                      // execute the formed equation
    s.replace(/\D|$/g,       // replace each symbol (and also add to the end) with:
      m=>`.0*${m=="*"?3:2}+` // case * = ".0*3+", else replace with ".0*2+"
    )
    +0                       // add "0" to the end for the trailing "+"
  )

परीक्षा

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

— user81655
स्रोत
9
.0विचार के लिए +1 ।
— निम्मी
3

फ्लेक्स + सी, 112 90 बाइट्स

 m=3,t;
%%
[0-9]+ t+=m*atoi(yytext);
\* m=2;
[+\n] m=3;
%%
main(){yylex();printf("%d",t);}

पहला किरदार एक स्पेस है। संकलन:

flex -o santa.c santa.l
cc santa.c -o santa -ll

STDIN से पढ़ता है, STDOUT को लिखता है। इनपुट EOF (कंसोल में Ctrl + D) द्वारा समाप्त किया जाता है।

— स्टेफानो सैनफिलिपो
स्रोत
2

गणितज्ञ, 70 बाइट्स

a=Tr[FromDigits/@StringExtract[#,"
"|"+"->;;,"*"->#2]]&;3#~a~1+2#~a~2&

StringExtractव्यक्तिगत संख्या निकालने के लिए उपयोग करता है।

— LegionMammal978
स्रोत
2

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

q'+NerN/{'*/3*5<:~~}%1b

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

व्याख्या

q      e# Read all input.
'+Ner  e# Replaces all "+" with linefeeds.
N/     e# Split the string around linefeeds (i.e. into houses).
{      e# Map this block over the list of house...
  '*/  e#   Split the string around the "*".
  3*   e#   Repeat the times.
  5<   e#   Truncate to 5 elements, keeping 3 copies of the naughty number and 2 copies of
       e#   the nice number.
  :~   e#   Evaluate each number (which may be an empty string which pushes nothing).
  ~    e#   Dump the list of numbers on the stack.
}%
1b     e# Sum all the numbers.
— मार्टिन एंडर
स्रोत
2

गंभीरता से, 38 30 बाइट्स

'*Ws`'0+'*@s'≈£M4rR*`MΣ+'+,WXX

हेक्स डंप:

272a57736027302b272a407327f79c4d3472522a604de42b272b2c575858

यह नया संस्करण ऑनलाइन दुभाषिया को तोड़ता है, लेकिन स्थानीय स्तर पर ठीक काम करता है। यहाँ एक उदाहरण चलाया गया है:

$ python2 seriously.py -f elves.srs
1*2+*+*4+1*
2*4+3*+1*6+*
*+*+4*2+1*1
*4+*3+1*+2*3
3*10+2*+*5+*

151

स्पष्टीकरण:

'*                              Push a "*" to make the stack truthy
  W                        W    Repeat while the top of stack is truthy
                                  (A whole bunch of instructions just turn the "*" into a
                                  zero on the first pass, so I'll list them here in the
                                  order they actually accomplish useful things:)
                          ,     Read in a line of input
   s                    '+      Split it on occurrence of "+"
    `               `M          Map this function over the list of strings.
     '0+                        Prepend a "0" to ensure a naughty number exists
        '*@s                    Split the string on "*"
            '≈£M                Map over the string with int() to convert it to int
                4rR             Push [3,2,1,0]
                   *            Dot product
                      Σ+        Sum all the houses, and add it to the results
                                  from the previous line of input
                            XX  Pop the "" and '+ from the stack, leaving only the
                                result to be implicitly output.

पुराना संस्करण:

'+ε'*`+'++,`╬Xs`≈`╗`'0+'*@s╜M[3,2]*`MΣ

हेक्स डंप:

272bee272a602b272b2b2c60ce587360f760bb6027302b272a4073bd4d5b332c325d2a604de4

यह ऑनलाइन की कोशिश करो

स्पष्टीकरण:

  ε'*                                   Initialize with two strings so the first + works
     `+'++,`╬                           Read in strings and compile them until "" is read
             X                          Throw away the ""
'+            s                         Split on +
               `≈`╗                     Chuck int function into reg0 to use within function
                   `               `M   Map this function over the list of houses
                    '0+                 Prepend a "0" to ensure a naughty number exists
                       '*@s             Split on *
                           ╜M           Convert the resulting list to ints with stored func
                             [3,2]*     Dot product with [3,2]
                                     Σ  Sum all houses

यह शायद कम हो सकता है अगर मैं बस प्रत्येक पंक्ति को अलग-अलग रूपांतरित करूं और उन सभी को अंत में अभिव्यक्त करूं। मैं बाद में इस पर गौर करूंगा।

— quintopia
स्रोत
2

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

User81655 की .0चाल की भिन्नता का उपयोग करना

$OFS='+';"$("$args"-replace'\*','.0*3+2*0'|iex)"|iex

अनप्लग्ड संस्करण

$OFS='+' # Set Output Field Separator to '+'
         # So if $arr = 1,2,3 then "$arr" will output 1+2+3

" # Cast result of subexpression to string using $OFS

    $( # Subexpression

        "$args" # Input is an array of arguments. Casting it to string using "$args"
                # is shorter then acessing the first element using $args[0]
                # $OFS wouldn't affect this, because input has only 1 element.

        -replace '\*' , '.0*3+2*0' # Replace every * with .0*3+2*0
                                   # Example: 1*+*1 becomes 1.0*3+2*0+.0*3+2*01

    ) | Invoke-Expression # Execute a result of subexpression as PS code.
                          # This will execute resulting multiline string line-by line
                          # and return an array of values, e.g.: 18,38,21,29,45

" Cast the aray above to string using '+' as Output Field Separator, e.g: 18+38+21+29+45

| Invoke-Expression # Execute the string above as PS code to get final result.
                    # E.g.: 18+38+21+29+45 = 151

उदाहरण का उपयोग करें

$Map = @'
1*2+*+*4+1*
2*4+3*+1*6+*
*+*+4*2+1*1
*4+*3+1*+2*3
3*10+2*+*5+*
'@

PS > .\SantaMap.ps1 $Map
151
— beatcracker
स्रोत
1

स्विफ्ट 2, 283 211 बाइट्स

func f(s:String)->Int{var r=0;for p in(s.characters.split{$0=="\n"}.map(String.init)){for v in p.utf8.split(43){let k="0\(v)".utf8.split(42);r+=(Int("\(k[0])")!)*3;r+=(k.count<2 ?0:Int("\(k[1])")!)*2}};return r}

इसका परीक्षण यहां स्विफ्टस्टब पर किया जा सकता है

Ungolfed

func f(s: String) -> Int{
    var r = 0

    //for every value in the input, split every "\n" and mapped
    //to a String array
    for p in (s.characters.split{$0=="\n"}.map(String.init)){

        //for every value in the split input, split again at every + (Decimal 43)
        for v in p.utf8.split(43){
            //change the value to "0" + v, which doesn't change the
            //input, but in the event that there is no input on the
            //left side, a "0" will be used
            //
            //then split on every * (Decimal 42)
            let k = "0\(v)".utf8.split(42)

           //add to the total count of elves the number on the left * 3
            r+=(Int("\(k[0])")!) * 3

            //add to the total count of elves the number on the left * 2
            r+=(k.count < 2 ? 0 : Int("\(k[1])")!) * 2
        }

        //return the number of elves
        return r
    }
}
— Jojodmo
स्रोत
1

पायथन 3, 141 114 112 बाइट्स

इस तरह मल्टी-लाइन इनपुट्स लेता है c("1*2+*+*4+1*\n2*4+3*+1*6+*\n*+*+4*2+1*1\n*4+*3+1*+2*3\n3*10+2*+*5+*")

lambda s:sum(a and(3-z)*int(a)or 0for j in s.split("\n")for i in j.split("+")for z,a in enumerate(i.split("*")))

Ungolfed:

def c(s):
    t = 0
    for j in s.split("\n"):
        for i in j.split("+"):
            for z,a in enumerate(i.split("*"))
                if a == "":
                    a = 0
                else:
                    a = int(a)
                t += (3-z) * a  # alternate a*3 and a*2
    return t
— Sherlock9
स्रोत
1

मैं सुपर लेट हूं, लेकिन मैं इसे एक शॉट वैसे भी देना चाहता था।

रूबी , 84 55 बाइट्स

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

->m{m.scan(/(\d*)\*(\d*)/).sum{|a,b|3*a.to_i+2*b.to_i}}

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

पुराने 84-बाइट का उत्तर जब मैंने पहली बार 2 साल पहले दिया था:

->m{m.split(/[+\n]/).map{|h|b,g=h.split(?*).map &:to_i
3*(b||0)+2*(g||0)}.inject :+}

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

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