इंटरक्वेर्टाइल मीन

Question

कार्य

दिया (किसी भी तरह से) एक क्रमबद्ध फ्लोटिंग प्वाइंट डेटासेट, किसी भी तरह से (सही मूल्य के 1 ‰ के भीतर) इंटरकार्टाइल माध्य ।

एक संभव एल्गोरिथ्म

1. डेटा बिंदुओं के निम्नतम और उच्चतम तिमाहियों को छोड़ दें।
2. शेष डेटा बिंदुओं की औसत (गणना द्वारा विभाजित राशि) की गणना करें।

नोट: यदि डेटासेट का आकार चार में समान रूप से विभाजित नहीं है, तो आपको उप-सेट द्वारा साझा किए गए डेटा पॉइंट को तौलना होगा । देखें उदाहरण मूल्यांकन 2 नीचे।

उदाहरण मूल्यांकन 1

दिए गए {1, 3, 4, 5, 6, 6, 7, 7, 8, 8, 9, 38}

1. डेटा गणना 12 है, इसलिए हम सबसे कम और उच्चतम 3 डेटा पॉइंट्स हटाते हैं:
   { 1, 3, 4, 5, 6, 6, 7, 7, 8, 8, 9, 38 }
2. शेष 6 डेटापॉइंट्स का औसत:
   (5 + 6 + 6 + 7 + 7 + 8) / 6 = 6.5

उदाहरण मूल्यांकन २

दिए गए {1, 3, 5, 7, 9, 11, 13, 15, 17}

1. गणना 9 है, इसलिए प्रत्येक तिमाही में 2¼ अंक हैं:
   { 1, 2, (0.25 × 5), (0.75 × 5), 7, 9, 11, (0.75 × 13), (0.25 × 13), 15, 17 }।
2. शेष 4.5 आंकड़ो का औसत:
   (0.75 × 5 + 7 + 9 + 11 + 0.75 × 13) / 4.5 + 9

Answer 1

सिलाब, 8 बाइट्स

trimmean

प्रलेखन देखें । डिफ़ॉल्ट रूप से discard=50, इसलिए IQM की गणना की जाती है।

संपादित करें: आप जानते हैं, यह एक तुच्छ अंतर्निर्मित उत्तर है, इसलिए मैं इसे सीडब्ल्यू के रूप में चिह्नित कर रहा हूं ।

Comments

मुझे लगता है कि यह विजेता होगा। बहुत बढ़िया।

— 19

Answer 2

अजगर , 11 10 बाइट्स

.O> <lQS * 4Ql
.OsPtc4S * 4

परीक्षण सूट।

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

यह सुनिश्चित करने के लिए इनपुट सूची को चौगुना करता है कि डेटा गणना 4 से विभाज्य है।

इसे अभी भी क्रमबद्ध करने की आवश्यकता है, क्योंकि *4प्रत्येक व्यक्तिगत तत्व के बजाय पूरी सूची पर लागू होता है।

फिर, यह सूची को चार समान भागों में विभाजित करता है, फिर पहले और अंतिम भाग को हटा देता है।

शेष सूची को चपटा किया जाता है और औसत लिया जाता है।

Answer 3

MATL , 12 11 बाइट्स

4Y"G"6L)]Ym

इनपुट एक क्षैतिज वेक्टर है, प्रारूप के साथ

[1, 3, 4, 5, 6, 6, 7, 7, 8, 8, 9, 38]

या

[1 3 4 5 6 6 7 7 8 8 9 38]

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

व्याख्या

4Y"    % Input horizontal vector implicitly. Repeat each element 4 times (run-length
       % decoding). The resulting array is still sorted.
G"     % Push input, for each: repeat as many times as the input size
  6L)  %   Remove first and last elements, by applying the index "2:end-1"
]      % End for each
Ym     % Compute mean. Display implicitly

Comments

मुझे नहीं मिला। 6L)पहले और आखिरी तत्वों को कैसे हटाता है? जब मैं इसे करता हूं, तो यह जटिल संख्याओं का एक गुच्छा धक्का देता है।

— DJMcMayhem

MATL में @DrGreenEggsandIronMan कॉम्प्लेक्स नंबर का इस्तेमाल किया जा सकता है। काल्पनिक इकाई सरणी के अंत के लिए खड़ी है, और यदि दो तीन संख्या हैं तो वे एक सीमा को परिभाषित करते हैं। इसलिए [2, -1+i]जब एक सूचकांक के रूप में उपयोग किया जाता है2:end-1

— लुइस मेन्डो

Answer 4

स्नोमैन , 66 बाइट्स

}vg","aS:10sB;aM4aRAsOal`,4nD,`aG0AaGal`NdE`AaL1AfL:nA;alaF,nDtSsP

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

@LeakyNun के उत्तरों के समान एल्गोरिथ्म का उपयोग करता है।

}         enable variables b, e, and g
vg        read a line of input into b
","aS     split on commas (in-place)
:10sB;aM  convert each element in resulting array to number ("frombase(10)-map")
4aR       repeat the array 4 times
AsO       sort the array
al        take the length and put it in e without consuming b (the array)
`,        swap b and e, then move e to g; now b=length g=array
4nD       divide b by 4 (4 was stored in e, which is why the array was moved)
,`        move the array and length/4 back to their original positions
aG        split the array into groups of length (length/4)
0AaG      take all elements with index >0 (i.e. remove the first element)
al        store the length of the new array in e again
`NdE`     bring it up to b, decrement, and put it back
AaL       take all elements with index <length-1 (i.e. remove last)
1AfL      flatten the array 1 level deep
:nA;      push a block that adds two numbers (to e)
al        store the length of this new array in g
aF        fold b over e (sum the numbers)
,         move g (the length) into e
nD        divide the sum by the length, resulting in the average
tSsP      to-string and print

Comments

यह भाषा भयानक लगती है। मुझे यह पसंद है।

— मेगो

Answer 5

पायथन 3, 50 बाइट्स

lambda n:sum(sorted(n*4)[len(n):-len(n)])/len(n)/2

Ideone यह!

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

यह पायथ में मेरे उत्तर का अनुवाद है ।

Answer 6

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

x4 xL '$ ḣLN $ S 
x LH x4ḊḣLNLN $ S H LH
x4œs4ḊṖFS ÷ एलएच

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

परीक्षण सूट।

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

यह पायथ में मेरे उत्तर का अनुवाद है ।

Comments

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

— एडम जूल

@ Adám कृपया अपना समाधान पोस्ट करें (ताकि मैं हाहा कॉपी कर सकूँ)

— लीक नून

मैं

— मारिनस को

हेयर यू गो!

— एडम

9 महीने से अधिक समय के बाद एक मौका, निश्चित रूप से

— लुइस मेंडो

Answer 7

पाइके, 16 13 बाइट्स

4*S4ftOsDsRl/

यहाँ कोशिश करो!

Comments

आपने मेरी लकीर को तोड़ दिया ...

— लीक नून

मैं बहुत माफी चाहता हूँ :(

— ब्लू

Answer 8

ब्रेकीलॉग , 21 बाइट्स

:3jo@4brbcLl/N,L+:N*.

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

व्याख्या

यह मूल रूप से @ LeakyNun का Pyth उत्तर एल्गोरिथम है।

:3j      Append 3 copies of the input to itself
o@4      Sort and split in 4 lists of equal length
brb      Remove the head and the tail of the list of lists
cL       Concatenate the 2 sublists into a list L
l/N,     N is the inverse of the length of L
L+:N*.   Output is the product of N and the sum of the elements of L

केवल छोटी चाल वहाँ लंबाई से विभाजित करने के बजाय लंबाई के व्युत्क्रम से गुणा करना है, क्योंकि 2 पूर्णांकों के बीच विभाजन पूर्णांक विभाजन है।

Answer 9

ऑक्टेव , 44 बाइट्स

@(x)mean(reshape(~~(1:4)'*x,[],4)(:,2:3)(:))

यह एक अनाम फ़ंक्शन को परिभाषित करता है।

इनपुट एक क्षैतिज वेक्टर है।

इसे आइडोन पर आज़माएं ।

व्याख्या

इनपुट क्षैतिज वेक्टर *चार मैट्रिक्स (पहले से निर्मित ~~(1:4)') के कॉलम वेक्टर द्वारा पहले मैट्रिक्स-गुणा ( ) है । परिणाम एक चार-स्तंभ मैट्रिक्स है जहां प्रत्येक पंक्ति इनपुट वेक्टर की एक प्रति है। तत्वों के रैखिक क्रम को बनाए रखते हुए, इसे 4-कॉलम मैट्रिक्स ( reshape(...,[],4)) में बदल दिया जाता है। केंद्र के दो कॉलम रखे गए हैं ( (:,2:3)) और एक ही कॉलम ( (:)) में रेखीयकृत हैं , जिनमें से माध्य की गणना की गई है ( mean(...))।

Comments

आप 1 बाइट को बचाने के [x;x;x;x]बजाय अधिक पठनीय के साथ बचा सकते हैं~~(1:4)'*x

— टॉम कारपेंटर

@(x)mean([x;x;x;x](:)((b=numel(x))+1:3*b))2 बाइट्स भी कम है। यही कारण है कि मैं साथ आया था, लेकिन यह मूल रूप से आपके दृष्टिकोण के समान है।

— टॉम कारपेंटर

@TomCarpenter मुझे नहीं लगता कि यह समान है। मुझे लगता है कि आपको इसे एक अलग उत्तर के रूप में पोस्ट करना चाहिए

— लुइस मेंडो

Answer 10

जे , 20 18 बाइट्स

2 बाइट्स @ @ मीलों के लिए धन्यवाद

# -:।। @% ~ - @ # + / @} #} 4 #]
- @ # (+ /% #) @} #} 4 #]।।

इसे ऑनलाइन आज़माएं! ( ऑनलाइन दुभाषिया )

प्रयोग

>> f =: -@#(+/%#)@}.#}.4#]
>> f 1 3 5 7 9 11 13 15 17
<< 9

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

यह पायथ में मेरे उत्तर का अनुवाद है ।

Comments

ऑनलाइन जम्मू दुभाषिया ।

— Adám

@ Adám धन्यवाद, जोड़ा गया।

— लीकेय नून

आप सीधे 18 बाइट्स के-@#(+/%#)@}.#}.4#] लिए मध्य भाग का औसत ले सकते हैं ।

— मील

Answer 11

दरअसल , 20 15 13 बाइट्स

; l;; +; + S╜ @ t╗ @ H / @ / 
; l; a; ए;; +; + StH /
; एल; τ; aττStHΣ /

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

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

यह पायथ में मेरे उत्तर का अनुवाद है ।

Comments

एक बार के लिए, वास्तव में एक उत्तर जो पठनीय (ग्रीक में) है।

— 15

@ Adám Pyth ASCII का उपयोग करता है।

— लीक नून

Answer 12

ऑक्टेव, 42bytes

ऑक्टेव के लिए एक और अनाम फ़ंक्शन।

@(x)mean([x;x;x;x](:)((b=numel(x))+1:3*b))

आप इसे ऑनलाइन आज़मा सकते हैं । बस उस कमांड को दर्ज करें, और फिर ans([1 2 4 5 6 9])या जो भी नंबर आवश्यक हैं।

यह एक इनपुट ऐरे से बनाना शुरू करता है जो प्रत्येक इनपुट एलिमेंट में से 4 के साथ पहले चार प्रतियों को लंबवत रूप से समतल करता है, और फिर इसे लंबवत रूप से समतल करता है। यह क्रम क्रम बनाए रखता है।

फिर इनपुट सरणी की लंबाई प्लस 1 से तीन गुना इनपुट सरणी की लंबाई से तत्वों की सीमा को निकालता है। क्योंकि नई सरणी चार गुना लंबी है, यह ऊपरी और निचले चतुर्थक को काट देती है।

अंत में नए एरे का माध्य लौटाया जाता है।

Answer 13

05AB1E, 15 बाइट्स

€D€D¹gô¦¨˜DOsg/

व्याख्या

€D€D             # quadruple each element in list
    ¹gô          # split into pieces the size of input
       ¦¨˜       # remove the first and last and flatten the middle 2
          DOsg/  # sum and divide by length

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

Answer 14

एपीएल (डायलॉग) , 15 बाइट्स

IQM←(+/÷≢)≢↓-∘≢↓4∘/

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

4∘/ प्रत्येक तत्व को चौगुना करें

-∘≢↓ कई अनुगामी तत्वों को छोड़ दें क्योंकि तर्कों में ऐसे तत्व हैं

≢↓ तर्क में तत्व के रूप में कई प्रमुख तत्वों को छोड़ दें

(… ) निम्नलिखित टैसिट फ़ंक्शन लागू करें:

 +/ योग

 ÷ द्वारा विभाजित

 ≢ टैली

Answer 15

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

a=>a.concat(a,a,a).sort(g=(x,y)=>x-y).slice(l=a.length,-l).reduce(g,0)/l/-2

स्पष्ट चौगुनी और तरह के दृष्टिकोण का उपयोग करता है, और मुझे उपयोग करने के लिए मिलता है reduce, जो अच्छा है। यहाँ एकमात्र चालबाज़ी है कि सभी बायर तत्वों को शून्य से घटाने के लिए सॉर्ट तुलनित्र का पुन: उपयोग करके 4 बाइट्स को बचाया जाए, जो मुझे -2lवह उत्तर देता है जो मुझे चाहिए।

Answer 16

गोल्फस्क्रिप्ट, 28 29 बाइट्स

~ .4 * $ \,। @ / 1> 2 <{+} * {+} * '/' @ 2 *
~ .4 * $ \,। @ / 1> 2 <{+} * {+} * \ 2 * -1? *

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

Answer 17

दरअसल, 12 बाइट्स

4α;l¼≈;±(Htæ

इसे ऑनलाइन आज़माएं! (वर्तमान में काम नहीं करता क्योंकि TIO कुछ संस्करण पीछे है)

स्पष्टीकरण:

4α;l¼≈;±(Htæ
4α            repeat each element 4 times
  ;l¼≈        length divided by 4, as integer
      ;±      copy, unary negate
        (Ht   remove first and last quartiles
           æ  mean

Answer 18

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

Mean@#[[(l=1+Length@#/4);;-l]]&@Sort@Join[#,#,#,#]&

सूची की चार प्रतियों को (सूची की लंबाई चार के गुणकों को नहीं रोकने के लिए), के "1 quarter the length of resulting list plus 1"माध्यम से भाग लेता है "1/4 length list + 1 from the end", उनकी लेता है Mean।

Answer 19

जावा 146 126 बाइट्स

ऐसे जावा बहुत क्रिया!

float m(float[]n){float r=0;int l=n.length,i=l/4;r-=(n[i])*(l%4)/4;r+=n[i*3]*(4-(l%4))/4;for(;i<l*3/4;r+=n[i],i++);return r/l*2;}

वृद्ध Ungolfed आंशिक रूप से परीक्षण के मामलों के साथ पठनीय है

/**
 *
 * @author rohan
 */
public Golf{

float m(float[]n){
//declarations 
float r=0;
int x,i=0,l=n.length;
//sum the array 
for(float m:n){r+=m;}
//remove the excess
for(;i<l/4;r-=n[i]+n[l-i-1],i++);
//weight the quartiles
r-=(n[l/4]+n[l*3/4])*(l%4)/4;
//return the sum/length but multiply by two since only half of the set is averaged
return r/l*2;
    }
static void interQuartileMean(float... set){
    System.out.println(new Golf().m(set));
}
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
    //test cases pass with flying colours
        interQuartileMean(1, 3, 4, 5, 6, 6, 7, 7, 8, 8, 9, 38);
        interQuartileMean(1, 3, 5, 7, 9, 11, 13, 15, 17);   
    }

}

Answer 20

क्लोजर, 82 81 बाइट्स

संपादित करें: "n by 2 n" भाग को फिर से लिखकर 1 बाइट कम।

#(let[n(count %)](*(/ n)0.5(apply +(subvec(vec(for[i % j(range 4)]i))n(* 3 n)))))

पिछला:

#(let[n(count %)](/(apply +(subvec(vec(for[i % j(range 4)]i))n(* 3 n)))(* 2.0 n)))

for4 बार-बार मान उत्पन्न करने के लिए उपयोग करता है, फ्लोट का उपयोग 2.0भिन्नात्मक परिणामों के लिए नहीं करता है, बाकी सिर्फ मानक है।

Answer 21

आर, 17 11 बाइट्स

mean(n,0.25)

मान लिया गया nहै कि मानक R रूप में इनपुट वेक्टर है n=c(1, 2, 3, ...)।

यह किसी भी तरह से आश्चर्यजनक नहीं है क्योंकि आर को "सांख्यिकीय कंप्यूटिंग के लिए भाषा" माना जा सकता है और इसमें कई सांख्यिकीय बिल्ट-इन हैं।

अद्यतन करें। सहेजे गए 6 बाइट्स rturnbull के लिए धन्यवाद क्योंकि trimडिफ़ॉल्ट रूप से पहला वैकल्पिक तर्क है!

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

a <- c(1, 3, 4, 5, 6, 6, 7, 7, 8, 8, 9, 38)
b <- c(1, 3, 5, 7, 9, 11, 13, 15, 17)
mean(a,trim=0.25) # Returns 6.5
mean(b,trim=0.25) # Returns 9

Comments

चूंकि trimडिफ़ॉल्ट दूसरा तर्क है, आपको इसे नाम देने की आवश्यकता नहीं है; 0.25को छोटा किया जा सकता .25या 1/4। यह आपको छह बाइट्स बचाता है।

— rturnbull

Answer 22

एक्सेल, 17 बाइट्स

=TRIMMEAN(A:A,.5)

आराम से इनपुट प्रारूप यह आसान बनाते हैं। कॉलम ए में प्रति पंक्ति इनपुट एक।