फिवेनम और थोड़ा सा

Question

(एक विरोधाभास, एक विरोधाभास, सबसे सरल विरोधाभास)

यह विभिन्न आर फ़ंक्शन से प्रेरित एक मल्टीपार्ट श्रृंखला का पहला भाग है।

काम

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

पांच नंबर सारांश में निम्नलिखित शामिल हैं:

• न्यूनतम मूल्य
• पहली चतुर्थक (Q1)
• मेडियन / दूसरा चतुर्थक (Q2)
• तीसरा चतुर्थक (Q3)
• अधिकतम मूल्य

चतुर्थकों को परिभाषित करने के कई अलग-अलग तरीके हैं, लेकिन हम आर द्वारा कार्यान्वित एक का उपयोग करेंगे:

परिभाषाएं:

• न्यूनतम और अधिकतम: क्रमशः सबसे छोटा और सबसे बड़ा मूल्य।
• माध्य: मध्यम मान अगर अगर प्रविष्टियों की एक विषम संख्या है, और दो मध्यम अधिकांश मान का समांतर माध्य है प्रविष्टियों में से एक और भी संख्या है। ध्यान दें कि इसका मतलब है कि माध्य एक गैर-पूर्णांक मान हो सकता है। हमें पहले मेडियन की गणना करनी थी ।$D$$D$
• प्रथम और तृतीय चतुर्थांश: डेटा को दो हिस्सों में विभाजित करें, जिसमें प्रत्येक में केंद्रीय तत्व शामिल है यदि में प्रविष्टियों की एक विषम संख्या है, और प्रत्येक आधे के औसत मूल्य का पता लगाएं। निचले आधे का माध्य प्रथम चतुर्थांश है, और ऊपरी आधे का माध्य तृतीय चतुर्थक है।$D$

उदाहरण:

$D=[1,2,3,4,5]$ । माध्य तब , और निचला आधा भाग , की पहली चतुर्थक की उपज है , और ऊपरी आधा , की तीसरी चतुर्थांश की उपज है ।$3$$[1,2,3]$$2$$[3,4,5]$$4$

$D=[1,3,3,4,5,6,7,10]$ । मंझला है , और कम आधा है , के पहले चतुर्थक उपज , और ऊपरी आधा है , का एक तिहाई चतुर्थक उपज ।$4.5$$[1,3,3,4]$$3$$[5,6,7,10]$$6.5$

अतिरिक्त नियम:

• इनपुट एक सरणी या आपकी भाषा के निकटतम समकक्ष के रूप में है।
• आप मान सकते हैं कि सरणी आरोही या अवरोही क्रम में क्रमबद्ध है (लेकिन कृपया निर्दिष्ट करें)।
• आप किसी भी सुसंगत क्रम में परिणाम वापस कर सकते हैं / प्रिंट कर सकते हैं , और जो भी लचीला प्रारूप आपको पसंद हो, लेकिन कृपया अपने उत्तर में आदेश और प्रारूप को निरूपित करें।
• निर्मित कार्यों के बराबर fivenumअनुमति दी जाती है, लेकिन कृपया अपना समाधान भी लागू करें।
• आप मान नहीं सकते कि प्रत्येक पाँच संख्याएँ पूर्णांक होंगी।
• स्पष्टीकरण को प्रोत्साहित किया जाता है।
• यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा में सबसे कम उत्तर जीतता है!

बेतरतीब ढंग से उत्पन्न परीक्षण मामले

1 1 1 1 1 2 2 2 2 2 3 3 4 4 4 4 4 5 5 5 -> 1 1.5 2.5 4 5 
1 2 2 2 4 4 5 5 6 7 7 8 9 9 9 9 9 10 10 10 -> 1 4 7 9 10 
2 2 2 6 8 10 15 16 21 22 23 24 26 33 35 38 38 45 46 47 48 -> 2 10 23 38 48 
1 2 9 -> 1 1.5 2 5.5 9 
1 2 3 3 3 4 9 -> 1 2.5 3 3.5 9
1 1 2 5 7 7 8 8 15 16 18 24 24 26 26 27 27 28 28 28 29 29 39 39 40 45 46 48 48 48 48 49 50 52 60 63 72 73 79 85 86 87 88 90 91 93 94 95 95 97 100 -> 1 25 45 76 100
2 2 4 4 6 8 10 11 13 14 14 15 17 21 23 24 26 27 27 28 28 30 31 33 33 34 36 36 38 38 39 40 41 42 42 43 45 45 47 47 47 47 47 48 48 48 50 51 53 53 55 56 56 56 57 57 58 62 62 63 64 64 65 65 66 67 67 67 68 69 69 71 71 71 74 79 80 81 81 81 82 82 83 83 86 86 86 87 89 94 94 94 95 95 97 98 99 100 100 100 -> 2 33.5 54 76.5 100
1 3 3 4 -> 1 2 3 3.5 4
1 3 3 3 4 -> 1 3 3 3 4

Answer 1

आर , 7 बाइट्स

fivenum

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

जाहिर है चुटीला जवाब। ;-)

दिलचस्प है, संख्यात्मक होने fivenum(x)पर summary(x)भी बराबर नहीं xहै, क्योंकि क्वांटाइल्स की गणना अलग-अलग की जाती है: fivenumडिसकंटिन्यूअल्स पर औसत, जबकि summaryआइसोलेट्स। आप विकल्प के साथ summaryव्यवहार करने के लिए मजबूर कर सकते हैं , लेकिन यह अभी भी की तुलना में लंबा हैfivenumquantile.type

आर , 51 बाइट्स

function(x)quantile(x,(0:4)/4,t=2+5*!sum(!!x)%%4-3)

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

जो आदेश 0 (न्यूनतम), 0.25 (Q1), 0.5 (माध्यिका), 0.75 (Q3) और 1 (अधिकतम) की मात्राओं की गणना करता है। t=2निर्दिष्ट करता है कि quantiles परिभाषित कर रहे हैं: 9 संभव प्रकार के होते हैं, और चुनौती परिभाषा मेल खाती है ज्यादातर मामलों में 2 टाइप करने के लिए, और टाइप करने के लिए 7 जब । ईमानदारी से, क्वांटाइल्स की परिभाषा का यह विकल्प थोड़ा अजीब है।$n\equiv 3\pmod 4$

ध्यान दें कि fivenumबिल्ट-इन का सोर्स कोड बहुत अलग (और बहुत लंबा) है।

Comments

केवल एक चीज जो मुझे मिल सकती है, quantileवह है नामांकित वेक्टर, जबकि fivenumअनाम है। हो सकता है कि समस्या का बहाव जहां fivenumइस्तेमाल किया गया हो?

— JAD

@JAD कोड unname()को शामिल करने से हल हो जाएगा। शायद ऐतिहासिक कारण हैं?

— रॉबिन राइडर

आपका फ़ंक्शन fivenumपरीक्षण मामलों में से दो सहित लंबाई 3 मॉड 4 के इनपुट से भिन्न होता है ।

— नाइट्रॉडन

@ नित्रोदन अर्घ! ध्यान देने के लिए धन्यवाद! यह अब ठीक होना चाहिए।

— रॉबिन राइडर

Answer 2

MATL , 18 बाइट्स

tno?t.5Xqh]5:q4/Xq

आउटपुट ऑर्डर बढ़ रहा है, जैसा कि परीक्षण मामलों में है।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

MATLAB, MATLAB की तरह, यदि आवश्यक हो तो (केवल माध्यिका के लिए चुनौती में निर्दिष्ट के रूप में) रैखिक प्रक्षेप का उपयोग कर मात्राओं की गणना करता है। पहली और तीसरी चतुर्थक के लिए आवश्यक व्यवहार को प्राप्त करने के लिए, इनपुट की लंबाई विषम होने पर यह मध्यिका को दोहराने के लिए पर्याप्त है। फिर परिणाम सिर्फ 0, .25, .5, .75 और 1 मात्राएँ हैं।

t       % Implicit input: numeric row array. Duplicate
no      % Length, parity
?       % If not zero (that is, if input length is odd)
  .5    %   Push .5
  Xq    %   .5-quantile: median. For even length it behaves as required
  h     %   Concatenate horizontally
]       % End
5:q     % Push [0 1 2 3 4]
4/      % Divide by 4, element-wise: gives [0 .25 .5 .75 1]
Xq      % [0 .25 .5 .75 1]-quantiles. Implicit display

Answer 3

जेली , 13 बाइट्स

œs2a\;WÆṁ;Ḣ;Ṫ

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

आदेश: [Q1, Q3, Q2/med, min, max]।

Answer 4

पायथन 3.8 (पूर्व-रिलीज़) , 66 बाइट्स

lambda l:[(l[~-i//4]+l[-~i//4])/2for i in[1,n:=len(l),~n-n,~n,-3]]

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

इनपुट और आउटपुट आरोही क्रम में हैं।

Answer 5

पायथन 3.8, 97 बाइट्स

lambda l:[l[0],l[-1]]+[(i[x(i)//2]+i[~x(i)//2])/2for i in(l[:~((x:=len)(l)//2-1)],l,l[x(l)//2:])]

यह मानता है कि इनपुट सूची आरोही क्रम में क्रमबद्ध है। f5-संख्या सारांश को वापस करने का कार्य है।

5-संख्या का सारांश क्रम में है:$\{min, max, Q1, Q2,Q3\}$

मैंने मेडियन की गणना करने के लिए फ्लिपटैक के उत्तर से कुछ संकेत लेकर कुछ बाइट्स को हटा दिया।

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

यह कैसे काम करता है?

lambda l:
    [l[0],l[-1]] # The minimum and maximum, because l is assumed to be sorted in ascending order
    +[(i[x(i)//2]+i[~x(i)//2])/2 # This line computes the median...
    for i in(l[:~((x:=len)(l)//2-1)],l,l[x(l)//2:])] # ...for each of these lists (the first half, the overall list, and the second half)
    # The (x:=len) is an assignment expression from Python 3.8.
    # It assigns the len function to the variable x but also returns len.
    # Therefore, x can be used as len to save a byte (yes, just one byte)

Comments

मध्यिका की गणना करने वाले फ़ंक्शन का उपयोग करना ठीक है; कि सबमिशन अब पायथन (3?) द्वारा नहीं किया जाएगा, लेकिन "पायथन + स्टैटिस्टिक्स पैकेज" या इसी तरह का।

— Giuseppe

Answer 6

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

≔⊖ＬθηＩＥ⟦⁰⊘÷η²⊘η⁻η⊘÷η²η⟧⊘⁺§θ⌊ι§θ⌈ι

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

≔⊖Ｌθη

अंतिम तत्व का सूचकांक प्राप्त करें।

ＩＥ

निम्न सरणी के तत्वों पर मैप करें और अलग-अलग लाइनों पर अंतर्निहित प्रिंट के लिए स्ट्रिंग करने का परिणाम दें।

⟦⁰⊘÷η²⊘η⁻η⊘÷η²η⟧

चतुर्थक तत्वों की स्थिति की गणना करें, जहां एक अतिरिक्त 0.5यह दर्शाता है कि मान दो आसन्न तत्वों का औसत है।

⊘⁺§θ⌊ι§θ⌈ι

प्रत्येक स्थिति में फर्श की स्थिति और छत के मूल्यों का औसत निकालकर चतुर्थक की गणना करें।

Answer 7

रूबी 2.7-प्रीव्यू 1 , 59 बाइट्स

एक सीधा ripoff के बंदरगाह XNOR के अजगर जवाब ।

->a{[1,n=a.size,~n-n,~n,-3].map{(a[~-@1/4]+a[-~@1/4])/2.0}}

इसे ऑनलाइन आज़माएं! (एक बाइट लंबे समय से टीआईओ रूबी 2.5 का उपयोग कर रहा है और इसमें ब्लॉक किए गए ब्लॉक पैरामीटर जैसे नहीं हैं @1)।

Answer 8

सी (जीसीसी) , 123 121 119 बाइट्स

-2 सीलिंग के लिए धन्यवाद।

एक सूची को आरोही क्रम में क्रमबद्ध मान लेता है।

क्रम में आउटपुट: न्यूनतम, Q1, Q2, Q3, अधिकतम।

#define M(K,x)(K[~-x/2]+K[x/2])/2.,
f(L,n,m)int*L;{m=n-n/2;printf("%d %f %f %f %d",*L,M(L,m)M(L,n)M((L+n/2),m)L[n-1]);}

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

Answer 9

05AB1E , 18 बाइट्स

2F2äнIR})€ÅmIWsà‚«

आउटपुट से आदेश है: [Q1, Q3, Q2, min, max]।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें । (मैंने {परीक्षण सूट के लिए एक प्रकार जोड़ा है , इसलिए परीक्षण मामलों को आदेश में सत्यापित करना आसान है [min, Q1, Q2, Q3, max]।)

स्पष्टीकरण:

2F                 # Loop 2 times:
  2ä               #  Split the list at the top of the stack into two halves
                   #  (which is the (implicit) input-list in the first iteration)
    н              #  Only leave the first halve
     IR            #  Push the input in reverse
       })          # After the loop: wrap all three lists into a list
         €         # For each of the lists:
          Åm       #  Get the middle/median depending on the parity of the size of the list
            I      # Then push the input-list again
             W     # Get the minimum (without popping)
              s    # Swap to get the input-list again
               à   # Get the maximum (by popping the list)
                ‚  # Pair the min-max together to a pair
                 « # And merge both lists together
                   # (after which the result is output implicitly)