13

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

चार्ली चैपलिन को उस प्रोग्राम को पंच करना चाहिए , जो छँटाई प्रक्रिया में कोई विसंगति होने पर मान्य होगा। मैक स्वेन अपने तत्काल बॉस को एक एल्गोरिथ्म साझा करता है जिसे उसे कोड करने की आवश्यकता होती है।

कलन विधि

L = List of Marble packets that's already sorted
L_ODD = List of packets with Odd Number of Marbles
L_EVEN = List of packets with Even Number of Marbles
Check_Digit = √(ΣL_ODD² + ΣL_EVEN²)

उसका काम चेक_ डिजीट का निर्धारण करना है और उसके साथ मिलान करना है जो कभी उसके बॉस की गणना करता है।

चार्ली चैपलिन अपने दोपहर के भोजन के घंटों के दौरान, मैक स्वैन की दराज को निर्धारित करने में सक्षम थे और निर्धारित करते थे कि उनके दराज में पहले 46 32 कॉलम (जिसका अर्थ है कि मैक 46 32 अक्षरों के साथ एक प्रोग्राम लिखने में सक्षम था) पर घूंसे के साथ एक ही कार्ड है ।

चार्ली चैपलिन को अब सभी कोड निनजा की मदद की आवश्यकता होगी, ताकि कम से कम लाइनों के साथ एक कार्यक्रम लिखा जा सके। वह 50 अंकों के बोनस की भी घोषणा करता है, अगर कोई ऐसा प्रोग्राम ले सकता है जो उसके बॉस से छोटा हो।

सारांश

सकारात्मक संख्याओं की एक सूची / सरणी / वेक्टर (विषम और समान) को देखते हुए, आपको एक फ़ंक्शन लिखने की आवश्यकता है, जो array(int [])/vector<int>/listसूची में विषम और सम संख्याओं के वर्गों के योग की जड़ को स्वीकार करेगा और गणना करेगा।

कार्यक्रम का आकार फ़ंक्शन के शरीर का आकार है, अर्थात फ़ंक्शन हस्ताक्षर के आकार को छोड़कर।

उदाहरण

List = [20, 9, 4, 5, 5, 5, 15, 17, 20, 9]
Odd = [9, 5, 5, 5, 15, 17, 9]
Even = [20, 4, 20]
Check_Digit = √(ΣOdd² + ΣEven²) = 78.49203781276162

ध्यान दें , कार्यान्वयन के फ्लोटिंग पॉइंट परिशुद्धता के आधार पर वास्तविक आउटपुट भिन्न हो सकते हैं।

स्कोर

~~स्कोर की गणना की जाती है Σ(Characters in your Program) - 46।~~ स्कोर की गणना की जाती है Σ(Characters in your Program) - 32। समुदाय से नियमित रूप से उत्थान के अलावा, सबसे कम नकारात्मक अंक को 50 अंक का अतिरिक्त बोनस मिलेगा।

संपादित करें

स्कोर की गणना करने के लिए उपयोग की जाने वाली ऑफसेट को 46 से 32 में बदल दिया गया है। ध्यान दें, यह लीडर-बोर्ड / बाउंटी पात्रता को प्रभावित नहीं करेगा या किसी भी समाधान को अमान्य नहीं करेगा।

निर्णय

निन्जा के बीच एक भीषण द्वंद्व के बाद, श्री चैपलिन को कुछ अद्भुत उत्तर मिले। दुर्भाग्य से कुछ जवाबों ने नियम का अनुचित लाभ उठाने की कोशिश की और बहुत उपयोगी नहीं थे। वह वास्तव में एक निष्पक्ष द्वंद्व चाहता था और जवाब जहां तर्क को फ़ंक्शन हस्ताक्षरों के भीतर कोडित किया गया था, अंततः इसका मतलब होगा कि फ़ंक्शन हस्ताक्षर समाधान का एक अभिन्न अंग है। अंत में, निंजा फायरफली स्पष्ट विजेता था और उसे उस बोनस से सम्मानित किया जिसके वह अच्छे हकदार थे। लीडरबोर्ड (हर दिन अपडेट किया गया)

╒══════╤═════════════════╤══════════════╤═════════╤════════╤═══════╕
├ Rank │      Ninja      │   Dialect    │ Punches │ Scores │ Votes ┤
╞══════╪═════════════════╪══════════════╪═════════╪════════╪═══════╡
│  0   │     FireFly     │      J       │   17    │  -15   │   6   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  1   │     tmartin     │     Kona     │   22    │  -10   │   2   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  2   │ Sven Hohenstein │      R       │   24    │   -8   │   7   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  3   │    Ben Reich    │  GolfScript  │   30    │   -2   │   1   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  4   │    mollmerx     │      k       │   31    │   -1   │   0   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  5   │ David Carraher  │ Mathematica  │   31    │   -1   │   3   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  6   │     tmartin     │      Q       │   34    │   2    │   1   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  7   │     daniero     │      dc      │   35    │   3    │   1   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  8   │    psion5mx     │    Python    │   38    │   6    │   2   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  9   │       O-I       │     Ruby     │   39    │   7    │   5   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  10  │      gggg       │    Julia     │   40    │   8    │   1   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  11  │ FakeRainBrigand │  LiveScript  │   50    │   18   │   0   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  12  │    Sylwester    │    Perl5     │   50    │   18   │   2   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  13  │     daniero     │     Ruby     │   55    │   23   │   1   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  14  │    vasuakeel    │ Coffeescript │   57    │   25   │   1   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  15  │      dirkk      │    XQuery    │   63    │   31   │   0   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  16  │  crazedgremlin  │   Haskell    │   64    │   32   │   0   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  17  │   Uri Agassi    │     Ruby     │   66    │   34   │   1   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  18  │     Sumedh      │     JAVA     │   67    │   35   │   0   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  19  │      Danny      │  Javascript  │   67    │   35   │   0   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  20  │     deroby      │      c#      │   69    │   37   │   1   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  21  │  Adam Speight   │      VB      │   70    │   38   │   0   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  22  │    Andrakis     │    Erlang    │   82    │   50   │   0   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  23  │      Sp0T       │     PHP      │   85    │   53   │   0   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  24  │    brendanb     │   Clojure    │   87    │   55   │   0   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  25  │  Merin Nakarmi  │      C#      │   174   │  142   │   0   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  26  │    Boopathi     │     JAVA     │   517   │  485   │   0   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  27  │      Noyo       │     ES6      │    ?    │   ?    │   2   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  28  │     shiona      │   Haskell    │    ?    │   ?    │   0   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  29  │      Vivek      │     int      │    ?    │   ?    │   0   │
└──────┴─────────────────┴──────────────┴─────────┴────────┴───────┘

code-golf sorting

— अभिजीत
स्रोत

8

सबसे कम स्कोर को बोनस की आवश्यकता क्यों है, वे पहले ही जीत चुके हैं?

— 20

6

इसके अलावा, 46 ऑफ़सेट ऑर्डर के संबंध में कुछ भी नहीं बदलता है।

— हावर्ड

@ मुझे लगता है कि उनका मतलब है कि वे सबसे कम स्कोरिंग जवाब +50 इनाम देंगे।

1

@ भिखारी: मैं वास्तव में जैसे ही मुझे अनुमति होगी मैं एक इनाम शुरू करूंगा। तो यह है कि मैं बोनस से क्या मतलब है।

— अभिजीत

1

अजी, चूहे। यहाँ मुझे लगा कि वहाँ नियमों का लाभ उठाया जाना चाहिए, और यह चतुराई यहाँ पुरस्कृत की जाएगी। ;] फिर भी, मजेदार सवाल, और अच्छी नौकरी, हर कोई!

— नॉयो

7

जे, 18 17 वर्ण - 32 = 1815

[:+/&.:*:2&|+//.]

(एक "फ़ंक्शन बॉडी" के रूप में, किसी नाम के लिए बाध्य या बाध्य होना चाहिए।)

व्याख्या

मैंने यह देखने का प्रयास किया कि प्रत्येक टुकड़ा क्या करता है, जैसे कि टोबिया एपीएल उत्तरों में करता है।

               +//. ]    NB. sum up partitions
           2&|           NB.   given by equality on (x mod 2)
        *:               NB. square,
   +/                    NB. sum,
     &.:                 NB. then revert the squaring (square-root)
                         NB. (f&.:g in general acts like g⁻¹(f(g(x))))
[:                       NB. (syntax to indicate composition of +/&.:*: and (2&| +//. ]))

+/&.:*:|@j./OI के जटिल परिमाण चाल का उपयोग करने के साथ अभी तक एक और दो पात्रों को बचाने के लिए प्रतिस्थापित किया जा सकता है ।

उदाहरण

   f =: [:+/&.:*:2&|+//.]
   f 20 9 4 5 5 5 15 17 20 9
78.492

— जुगनू
स्रोत

9

ईएस 6, (48 - 32) = 16 (1 - 32) = -31

मूल संस्करण:

f=l=>(e=o=0)+l.map(x=>x%2?e+=x:o+=x)&&Math.hypot(e,o)

संपूर्ण फ़ंक्शन की परिभाषा 53 वर्ण है, शरीर केवल 48 है।

अद्यतन संस्करण, समस्या की परिभाषा का पूरा फायदा उठाते हुए और शरीर की हर चीज को हस्ताक्षर में बदलकर:

f=(l,e=0,o=0,g=x=>x%2?e+=x:o+=x,c=l.map(g)&&Math.hypot(e,o))=>c

नई फ़ंक्शन परिभाषा अब कुल 63 "घूंसे" है, लेकिन फ़ंक्शन बॉडी अब केवल एक डैम चरक लांग है। इसके अलावा यह अब वैश्विक नामस्थान को भ्रष्ट नहीं करता है! : डी

उपयोग:

>>> f([20, 9, 4, 5, 5, 5, 15, 17, 20, 9])
78.49203781276161

— NOYO
स्रोत

... और अब मुझे थोड़े गंदे लग रहे हैं। :]

— १०:१४ पर नोयो

+1, मैंने आपका ES6 समाधान हटा दिया है क्योंकि आपका तरीका बेहतर है :)

— फ्लोरेंट

हा हा धन्यवाद। हम देखेंगे कि क्या नियम बदल जाते हैं, जब ओपी इसे देखता है ..?]

— नियू

1

खैर, ऐसा लगता है कि नियमों को वास्तव में बदल दिया गया था, भले ही एक जवाब स्वीकार किए जाने के बाद और इनाम से सम्मानित किया गया हो। ओह अच्छा! मैं अभी भी इसे चुनौती के नियमों के अनुसार सबसे कम स्कोर के साथ समाधान मानता हूं। :]

— नॉयो

1

वास्तव में मुझे उन सी कोड-कंटेस्टेंट्स की याद दिलाता है जहां लोग प्रीप्रोसेसर में सभी तरह की चालबाजी करते हैं जो बहुत जटिल सामान लौटते हुए प्रतीत होता है कि 'सरल' फ़ंक्शन है। शुद्ध परिणाम निश्चित रूप से ऐसा था कि संकलन में घंटों और घंटों (और घंटों) का समय लगता था जबकि वास्तविक निष्पादन सेकंड के एक अंश में 100k संख्या (या ऐसा कुछ) के लिए पीआई लौटता था, क्योंकि परिणाम में बहुत हार्ड-कोडित था बाइनरी। वैसे भी, हालांकि मुझे लगता है कि हम दोनों जानते हैं कि आप धोखा दे रहे थे, मैं कहूंगा "अच्छी तरह से खेला गया सर" = पी

— अपमानजनक

7

आर, (24 - 32) = 328

f=function(x)
    sum(by(x,x%%2,sum)^2)^.5

फ़ंक्शन बॉडी में 24 वर्ण होते हैं।

उपयोग:

f(c(20, 9, 4, 5, 5, 5, 15, 17, 20, 9))
[1] 78.49204

— स्वेन होहेंस्टीन
स्रोत

Ergh !!! आपके पास ठीक वैसा ही समाधान है जैसा मैंने अभी विस्तृत किया है !! sqrt(sum(by(x,x%%2,sum)^2))मैंने केवल sqrt को ऑप्टिमाइज़ नहीं किया है .... लानत है :-) +1 :-) PS: यह दिलचस्प है कि byशिती आउटपुट फॉर्मेट के कारण पहली बार में कैसा लगता है, लेकिन जब आप sumइसे चलाते हैं तो यह तय हो जाता है; ;-)

— टॉमस

@ टोमस इस उदाहरण में, byएक-आयामी सरणी देता है। फ़ंक्शन के परिणाम के आधार पर किसी को फ़ंक्शन का न्याय नहीं करना चाहिए print.by।

— स्वेन होइनस्टीन

नहीं, byएक सरणी नहीं लौटाता है (btw, आप "सरणी" से क्या मतलब है? आर में कोई भी नहीं हैं। आप शायद एक वेक्टर का मतलब है), न ही एक वेक्टर। byवर्ग की वस्तु देता है by।

— टॉमस

@Tomas वहाँ रहे हैं एक नज़र में आर Have में सरणियों ?array। इसके अलावा, is.array(by(1,1,I))रिटर्न TRUE।

— स्वेन होइनस्टीन

6

रूबी 2.1+ - (39 अक्षर कुल - 7 गैर-शरीर - 32 ऑफसेट = 0)

थोड़ा अलग दृष्टिकोण। मैं एक जटिल संख्या बनाने a+b*iऐसी है कि aऔर bभी और विषम संख्या की रकम में हैं listक्रमश:। फिर मैं सिर्फ पूर्ण मूल्य लेता हूं।

f=->l{l.reduce{|s,x|s+x*1i**(x%2)}.abs}

मेरा पिछला समाधान, जो 5 अक्षर लंबा है, लेकिन 1.9.3+ पर काम करता है:

f=->l{l.reduce{|s,x|s+x*?i.to_c**(x%2)}.abs}

अंतिम नोट पर, अगर रेल + रूबी 2.1+ की अनुमति थी, तो हम Array#sumशरीर को मात्र 25 वर्णों तक नीचे लाने के लिए उपयोग कर सकते हैं :

l.sum{|x|x+1i**(x%2)}.abs

— OI
स्रोत

बहुत चालाक, मुझे यह पसंद है! यह मुझे जम्मू में कुछ वर्णों को भी बचाएगा।

— फायरफली

धन्यवाद, @FireFly तुम्हारा अच्छा है कुछ समय में जे सीखना होगा। चीयर्स!

— OI

आपको केवल फ़ंक्शन के शरीर को गिनना है, मैं कहता हूं कि 37 वर्ण हैं।

— स्टेनेस्लाग

टिप @steenslag के लिए धन्यवाद। अपडेट किया गया। मैंने नए कॉम्प्लेक्स शाब्दिक शॉर्टहैंड का उपयोग करके एक अतिरिक्त 5 पात्रों का मुंडन भी किया। केवल रूबी 2.1 और इसके बाद के संस्करण में काम करता है।

— OI

5

पायथन 2.7: 45, nay: 40, nay: 38 - 32 = 6

यहां बहुत कुछ नया नहीं है, बस हाल ही में पाइथागोरस चुनौती में देखी गई जटिल संख्या चाल का एक संयोजन, कॉम्पैक्टनेस के लिए लैम्ब्डा, और वाक्यविन्यास / कोष्ठक न्यूनतम:

lambda x:abs(sum(a*(1-a%2+a%2*1j)for a in x))

अद्यतन - कुछ वर्ण सहेजे गए। जटिल घटक को 0/1 तक बढ़ाने की चाल के लिए @DSM को धन्यवाद।

lambda x:abs(sum(a*1j**(a%2)for a in x))

ठीक है, सवाल पढ़कर और 'फंक्शन के बॉडी' को पहचानकर काउंट रूल एक और 2 चार्ट बचाता है:

def f(x):
    return abs(sum(a*1j**(a%2)for a in x))

iPython परीक्षण:

In [650]: x = [20, 9, 4, 5, 5, 5, 15, 17, 20, 9]

In [651]: print (lambda l:abs(sum(a*(1-a%2+a%2*1j)for a in l)))(x)
78.4920378128

...

In [31]: def f(x):
   ....:     return abs(sum(a*1j**(a%2)for a in x))
   ....:

In [32]: f(x)
Out[32]: 78.49203781276162

— psion5mx
स्रोत

अच्छा! यह समस्या absजटिल नंबरों के लिए बिल्कुल निर्मित थी जैसे

— jozxyqk

4

एपीएल (27 - 46 = -19)

{.5*⍨+/2*⍨+⌿⍵×[1]z,⍪~z←2|⍵}

उदाहरण के लिए:

      {.5*⍨+/2*⍨+⌿⍵×[1]z,⍪~z←2|⍵} 20 9 4 5 5 5 15 17 20 9
78.49203781

— मारीनस
स्रोत

4

गणितज्ञ 31-32 = -1

√Tr[(Tr/@GatherBy[#,OddQ])²]//N &

GatherBy[#,OddQ] सम-पैकेट, विषम-पैकेट सूचियों का निर्माण करता है।

आंतरिक Trकुल योग पाता है, जिसमें दोनों चुकता होते हैं और फिर अभिव्यक्त होते हैं (बाहरी द्वारा Tr)।

N एक अपरिमेय संख्या (पूर्णांक का वर्गमूल) से दशमलव सन्निकटन में परिवर्तित होता है।

उदाहरण

√Tr[(Tr/@GatherBy[#,OddQ])²]//N &[{9, 5, 5, 5, 15, 17, 9, 20, 4, 20}]

78.492

यदि f[n_]:=गिनती में शामिल नहीं है, तो एक अतिरिक्त चरित्र को बचाया जा सकता है।

    f[n_]:=
    √Tr[(Tr/@GatherBy[n,OddQ])²]//N

उदाहरण

f[{9, 5, 5, 5, 15, 17, 9, 20, 4, 20}]

78.492

— DavidC
स्रोत

3

कोना, 22 - 32 = -10

{(+/(+/'x@=x!2)^2)^.5}

— tmartin
स्रोत

3

पर्ल 5: (50 - 32 = 18)

map{$0[$_&1]+=$_}@ARGV;print sqrt$0[0]**2+$0[1]**2

— Sylwester
स्रोत

+1 शायद आप का उपयोग करके कुछ वर्ण को बचाने कर सकते हैं sayके बजाय printऔर <>के बजाय @ARGV(जबकि STDIN पर आर्ग की आपूर्ति के बजाय कमांड लाइन पर)

— टॉमस

@ टॉमास का उपयोग करने की sayआवश्यकता नहीं होगी use? तर्क सरणी से स्विच करने के <>लिए एक अतिरिक्त की आवश्यकता होगी split/ /,।

— सिल्वेस्टर

1) नहीं, कहते हैं कि सुविधा कमांड लाइन से सक्षम की जा सकती है । 2) मुझे लगता है कि यदि आप प्रति पंक्ति उन संख्याओं को प्रदान करते हैं तो कोई विभाजन की आवश्यकता नहीं होगी।

— टॉमस

3

डीसी 3 (35 - 32)

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

[d2%dsP;S+lP:Sz0<L]dsLx0;S2^1;S2^+v

मान लेता है कि संख्याएँ पहले से ही स्टैक पर हैं, और परिणाम को एकमात्र मान के रूप में छोड़ देती है जब यह किया जाता है।

परीक्षा:

$ dc  
20 9 4 5 5 5 15 17 20 9  
[d2%dsP;S+lP:Sz0<L]dsLx0;S2^1;S2^+v 
p
78

डीसी 16 (48 - 32)

पहला संस्करण रजिस्टरों का उपयोग करते हुए ओ और ई को विषम और समान संख्या में संग्रहीत करता है।

0dsose[dd2%rd1+2%*lo+so*le+sez0<x]dsxxle2^lo2^+v

— daniero
स्रोत

1

Dc का उपयोग करने के लिए +1। हा हा sose;-) शायद आप dc सरणी कमांड का उपयोग करके कम परिणाम प्राप्त कर सकते हैं ?

— टॉमस

1

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

— डानिएरो

आपका स्वागत है, मुझे पता था कि इससे :-)

— टॉमस

2

पायथन, 9 (55 - 46)

lambda x:sum([sum([i*(d-i%2) for i in x])**2for d in(0,1)])**0.5

लैम्ब्डा फंक्शन का उपयोग करने से न्यूलाइन, टैब और पर कुछ बाइट्स बचते हैं return।

उदाहरण:

x = [20, 9, 4, 5, 5, 5, 15, 17, 20, 9]
print (lambda x:sum([sum([i*(d-i%2) for i in x])**2for d in(0,1)])**0.5)(x)
78.4920378128

— Flogo
स्रोत

2

रूबी (66 - 32 = 34)

f=->a{o,e=a.partition(&:odd?).map{|x|x.reduce(:+)**2};(e+o)**0.5}

परीक्षा:

f.([20, 9, 4, 5, 5, 5, 15, 17, 20, 9])
=> 78.49203781276162

— उड़ी अगासी
स्रोत

1

Math.hypot *a.partition(&:odd?).map{|x|eval x*?+}कुछ चरों से

— दाढ़ी बनाता है

2

रूबी, 55 - 46 = 9

f=->a{h=[0,0];a.map{|v|h[v%2]+=v};e,o=h;(e*e+o*o)**0.5}

परीक्षा:

f[[20, 9, 4, 5, 5, 5, 15, 17, 20, 9]] => 78.49203781276162`

— daniero
स्रोत

1

आप इसके लिए एक सरणी का उपयोग कर सकते हैं h: f=->a{h=[0,0];a.map{|v|h[v%2]+=v};e,o=h;(e*e+o*o)**0.5}

— नील स्लेटर

@NeilSlater दोह! धन्यवाद :)

— daniero

2

क्यू, 34 - 32 = 2

{sqrt sum{x*x}(+/')(.)x(=)x mod 2}

।

q){sqrt sum{x*x}(+/')(.)x(=)x mod 2} 20 9 4 5 5 5 15 17 20 9
78.492037812761623

— tmartin
स्रोत

2

जूलिया, 40-46 = -6

कार्यान्वयन

function f(l)
    a=sum(l);b=sum(l[l%2 .==1]);hypot(a-b,b)
end

उत्पादन

julia> f([20, 9, 4, 5, 5, 5, 15, 17, 20, 9])
78.49203781276161

— gggg
स्रोत

2

कॉफ़ीस्क्रिप्ट, (57 - 32 = 25)

implementaion

f=(a)->r=[0,0];r[e%2]+=e for e in a;[e,o]=r;(e*e+o*o)**.5

— वासु अडारी
स्रोत

मुझे कॉफ़ीस्क्रिप्ट नहीं पता है, लेकिन मुझे आश्चर्य है कि अगर आप अंतरिक्ष को हटा सकते हैं +=और बदल 0.5सकते हैं.5

— user12205

2

GolfScript 30

.{2%},]{{+}*}/.@\-]{2?}/+2-1??

मुझे नहीं लगता कि इस पर गोल्फस्क्रिप्ट के पास एक मौका है!

— बेन रीच
स्रोत

2

c #: 69-32 = 37

double t=l.Sum(),o=l.Sum(x=>x*(x%2)),e=t-o;return Math.Sqrt(o*o+e*e);

पूर्ण कोड:

class Program
{
    static void Main(string[] args)
    {
        int[] list = { 20, 9, 4, 5, 5, 5, 15, 17, 20, 9 };
        Console.WriteLine(F(list));
        Console.ReadKey();
    }

    static double F(int[] l)
    {
        double t = l.Sum(),  // total sum of all elements
               o = l.Sum(x => x * (x % 2)),  // total of odd elements, if even %2 will return zero
               e = t - o; // even = total - odd
        return Math.Sqrt(o * o + e * e);
    }        
}

पुनश्च: सिर्फ मनोरंजन के लिए, यह भी काम करता है, दुख की बात यह है कि आवश्यक वर्णों की संख्या में परिवर्तन नहीं होता है:

double t=l.Sum(),o=l.Sum(x=>x*(x%2));return Math.Sqrt(t*t-2*o*(t-o));

— deroby
स्रोत

2

प्रोलोग (73 - 32 = 41)

यहाँ हम फंक्शन बॉडी के रूप में ': -' के बाद सब कुछ गिनते हैं।

f([],0,0,0).
f([H|T],O,E,X):-(1 is H mod 2,f(T,S,E,_),O is H+S,!;f(T,O,S,_),E is H+S),sqrt(O*O+E*E,X).

कॉल फ़ंक्शन जैसे:

f([20, 9, 4, 5, 5, 5, 15, 17, 20, 9],_,_,X).

— mwcoomber
स्रोत

1

मतलाब (44 - 46 = -2)

समारोह शरीर 44 वर्ण है:

C=mod(A,2)>0;O=(sum(A(C))^2+sum(A(~C))^2)^.5

कुल समारोह इस प्रकार है:

function O = Q(A)
C=mod(A,2)>0;O=(sum(A(C))^2+sum(A(~C))^2)^.5
end

समारोह के परीक्षण:

>> A = [20 9 4 5 5 5 15 17 20 9];
>> Q(A)

O =

   78.4920


ans =

   78.4920

>> B = [8 3 24 1 9 8 4 5 52];
>> Q(B)

O =

   97.6729


ans =

   97.6729

— virusered
स्रोत

1

पायथन 2.7 - 64-46 = 18

यह कुछ zipजादू का उपयोग करके कम किया जा सकता है , लेकिन अभी के लिए:

(sum(s for s in x if s%2)**2+sum(s for s in x if s%2==0)**2)**.5

पूरा होने के लिए, यह पता चला है कि आप ज़िप जादू कर सकते हैं, लेकिन यह आपको अधिक लागत (कुछ पात्रों द्वारा) देता है, इसलिए उपरोक्त खड़ा है, जब तक कि कोई इनमें से किसी को भी सुधार नहीं सकता है:

sum(map(lambda i:sum(i)**2,zip(*[[(0,i),(i,0)][i%2]for i in x])))**.5

1

आपको योग के अंदर [वर्ग कोष्ठक] की आवश्यकता नहीं है ()।

— डेनिएरो

1

मुझे लगता है कि आप जटिल विमान में काम करके इसे बेहतर कर सकते हैं, जैसे abs(sum(1j**(i%2)*i for i in x))।

— डीएसएम

@DSM यह पागल है! मैने इसके बारे में कभी नहीं सोचा था। मैं इसमें बहुत अधिक परिवर्तन नहीं कर सकता, लेकिन कृपया कर दें और उत्तर दें ताकि मैं इसे बढ़ा सकूं!

@DSM: मेरे दिमाग में एक ऐसा ही संस्करण था, लेकिन आपका स्लीकर है

— अभिजीत

क्या पायथन स्वीकार करता है !s%2? यह कम से कम एक वृद्धिशील परिवर्तन है जिसे आप स्वीकार कर सकते हैं

— न कि चार्ल्स

1

सी # 174

using System;class P{static void Main(){double[] L={20,9,4,5,5,5,15,17,20,9};double O=0,E=0;foreach(int i in L){if(i%2==0)E+=i;else O+=i;}Console.Write(Math.Sqrt(E*E+O*O));}}

पठनीय

using System;
class P
{
  static void Main()
  {
      double[] L = { 20, 9, 4, 5, 5, 5, 15, 17, 20, 9 };
      double O = 0, E = 0;
      foreach (int i in L)
      {
        if (i % 2 == 0)
            E += i;
        else
            O += i;
      }
      Console.Write(Math.Sqrt(E * E + O * O));
   }
}

चार्ली का आउटपुट

— मेरिन नाकामरी
स्रोत

आपने इसे बिल्कुल नहीं गढ़ा है। हम एक समाधान प्राप्त करने की कोशिश कर रहे हैं जो बॉस के पंचकार्ड पर फिट बैठता है!

— रेकिंग

क्यों नहीं? कृपया समझाईए।

— मेरिन नाकामरी

2

आपका कोड पूरी तरह से रिक्त स्थान के साथ प्रेरित है। कोड गोल्फ सबसे कम चरित्र गिनती प्राप्त करने के बारे में है। इस प्रश्न को कोड-गोल्फ टैग किया गया है ।

— 1

धन्यवाद राईकिंग। मैंने इसे संपादित किया। मेरे पास अब कम पात्र हैं। :)

— मेरिन नाकामरी

मुझे लगता है कि सूची को इनपुट के रूप में प्रदान किया जाना चाहिए, हार्डकोड नहीं।

— Timwi

1

क्लोजर = 87 - 46 = 41

(defn cd [v]
  (let [a apply ** #(* % %)]
    (Math/sqrt(a + (map #(** (a + (% 1)))(group-by even? v))))))

हालांकि, शायद ही मुहावरेदार।

— brendanb
स्रोत

1

हास्केल, 64 सी - 46 = 18

c x=sqrt$fromIntegral$s(f odd x)^2+s(f even x)^2
f=filter
s=sum

पढ़ने में भी मुश्किल नहीं है। उदाहरण रन:

*Main> c [1..10]
39.05124837953327

— danmcardle
स्रोत

1

int e=0,o=0;for(int i :n){if(i%2==0)e+=i;else o+=i;}System.out.println(Math.sqrt(e*e+o*o));

जावा कोड में वास्तविक विधि

public static void checkDigit(int[] n)
{
    int e=0,o=0;for(int i :n){if(i%2==0)e+=i;else o+=i;}System.out.println(Math.sqrt(e*e+o*o));
}

टेस्ट क्लास

public class Sint
{
    public static void main(String[] args)
    {
        if(args == null || args.length == 0)
            args = "20 9 4 5 5 5 15 17 20 9".split(" ");
        int[] n = null;
        try
        {
            n = new int[args.length];
            for(int i=0; i<args.length; i++)
                n[i] = Integer.parseInt(args[i]);
            System.out.print("int array is: ");
            for(int dd : n) System.out.print(dd+", ");
            System.out.print("\n");
            checkDigit(n);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }

    public static void checkDigit(int[] n)
    {
        int e=0,o=0;for(int i :n){if(i%2==0)e+=i;else o+=i;}System.out.println(Math.sqrt(e*e+o*o));
    }
}

— विवेक
स्रोत

1

PHP 85-32 = 53

$a=$b=0;foreach($x as $q){if(($q%2)==0)$a=$a+$q;else$b=$b+$q;}echo sqrt($a*$a+$b*$b);

यह एक नौसिखिया होने के नाते सबसे अच्छा है। मुझे यकीन है कि कुछ छोटे संस्करण भी होने चाहिए।

संपादित करें:

कोड का एक कम संस्करण हो सकता है:

foreach($x as$q)($q%2)?$a=$a+$q:$b=$b+$q;echo sqrt($a*$a+$b*$b);

इस संस्करण में केवल 64 (मूल उत्तर से 21 कम) वर्ण हैं।

कहा तो, 64-32 = 32

— Sp0T
स्रोत

स्वतंत्र रूप से किया, 58 आधार मिला:foreach($l as$m)$m%2?$o+=$m:$e+=$m;echo sqrt($o*$o+$e*$e);

— योदा

1

VB.net (81c - 11c = 70) - 32 = 38

शब्द का वाया उदार उपयोग एक फ़ंक्शन लिखें

Function(n)Math.Sqrt(n.Sum(Function(x)x Mod 2=0)^2+n.Sum(Function(x)x Mod 2=1)^2)

— एडम स्पाइट
स्रोत

1

XQuery, (63 - 32 = 31)

कार्यान्वयन

declare default function namespace 'http://www.w3.org/2005/xpath-functions/math';
declare function local:f($s) {
  sqrt(pow(fn:sum($s[. mod 2=0]),2)+pow(fn:sum($s[. mod 2=1]),2))
};

उत्पादन

local:f((20, 9, 4, 5, 5, 5, 15, 17, 20, 9))

बेसएक्स का उपयोग XQuery प्रोसेसर के रूप में किया गया था।

— मोनिका को बहाल करना - dirkk
स्रोत

1

एरलैंग: 82 सी - 32 = 50

fun(L)->F={lists,sum},O=[X||X<-L,X rem 2>0],E=F(L--O),math:sqrt(F(O)*F(O)+E*E)end.

इसके लिए एरलांग महान नहीं है। अधिकांश शॉर्टकट अधिक वर्ण (टुपल्स आदि) होने पर समाप्त होते हैं

नोट की केवल वास्तविक बातें:

{lists,sum} के लिए एक समारोह संदर्भ है lists:sum और इसे कॉल किया जा सकता है
यहां तक कि संख्याओं की गणना पूरी सूची से विषम संख्या सूची को घटाकर --( सूची में घटाकर ) की जाती है

कॉल का उपयोग कर सकते हैं:

fun(L)->F={lists,sum},O=[X||X<-L,X rem 2>0],E=F(L--O),math:sqrt(F(O)*F(O)+E*E)end([20,9,4,5,5,5,15,17,20,9]).

आउटपुट: 78.49203781276162

— Andrakis
स्रोत

1

हास्केल

५। - ३२ = २५

Crazedgremlins उत्तर का सीधा अनुकूलन:

c x=sqrt$read$show$sum(odd%x)^2+sum(even%x)^2
(%)=filter

अनुकूलन:

read$showसे कम है fromIntegral- 3 वर्ण
s=sum\nऔर दो sकी कुल लंबाई 8 वर्ण है, दो sumकी सिर्फ 6 वर्ण हैं। - 2 वर्ण
ऑपरेटर में फ़िल्टर करना व्हॉट्सएप की आवश्यकता को पूरा करता है - 2 वर्ण

मैंने ऑपरेटर के लिए अधिक सामान जोड़ने की भी कोशिश की, लेकिन यह केवल लंबे समय तक समाप्त हो गया:

c x=sqrt$read$show$odd%x+even%x
(%)=(((^2).sum).).filter

— shiona
स्रोत

सबसे छोटा कार्यक्रम क्रमबद्ध करने के लिए विषम और सम श्रेणी में संख्याओं की सूची

जे, 18 17 वर्ण - 32 = 1815

व्याख्या

उदाहरण

ईएस 6, (48 - 32) = 16 (1 - 32) = -31

आर, (24 - 32) = 328

रूबी 2.1+ - (39 अक्षर कुल - 7 गैर-शरीर - 32 ऑफसेट = 0)

पायथन 2.7: 45, nay: 40, nay: 38 - 32 = 6

एपीएल (27 - 46 = -19)

गणितज्ञ 31-32 = -1

उदाहरण

कोना, 22 - 32 = -10

पर्ल 5: (50 - 32 = 18)

डीसी 3 (35 - 32)

डीसी 16 (48 - 32)

रूबी (66 - 32 = 34)

रूबी, 55 - 46 = 9

क्यू, 34 - 32 = 2

जूलिया, 40-46 = -6

GolfScript 30

c #: 69-32 = 37

प्रोलोग (73 - 32 = 41)

मतलाब (44 - 46 = -2)

पायथन 2.7 - 64-46 = 18

क्लोजर = 87 - 46 = 41

हास्केल, 64 सी - 46 = 18

जावा कोड में वास्तविक विधि

VB.net (81c - 11c = 70) - 32 = 38

XQuery, (63 - 32 = 31)

एरलैंग: 82 सी - 32 = 50

हास्केल