मेडियन की गणना करें

Question

चुनौती

वास्तविक संख्याओं की एक गैर-रिक्त सूची को देखते हुए, इसके माध्य की गणना करें।

परिभाषाएं

माध्यिका की गणना निम्नानुसार की जाती है: पहले सूची को क्रमबद्ध करें,

• यदि प्रविष्टियों की संख्या विषम है , तो माध्य क्रमबद्ध सूची के केंद्र में मान है,
• अन्यथा माध्य क्रमबद्ध सूची के केंद्र के निकटतम दो मूल्यों का अंकगणित माध्य है।

उदाहरण

[1,2,3,4,5,6,7,8,9] -> 5
[1,4,3,2] -> 2.5
[1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,-5,100000,1.3,1.4] -> 1.5
[1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,-5,100000,1.3,1.4] -> 1.5

Comments

क्या हम 2 (जैसे 7/2या 8/2) पर एक अंश के रूप में आउटपुट कर सकते हैं

— गेहूं जादूगर

के अनुसार इस अंशों ठीक कर रहे हैं।

— दोष

यह पहले से ही चुनौती कैसे नहीं है?

— orlp

@orlp यह इस चुनौती का सबसेट है ।

— AdmBorkBork

यह एक अच्छा सबसे तेज़ कोड चुनौती भी है क्योंकि कुछ दिलचस्प रैखिक समय एल्गोरिदम हैं।

Answer 1

पायथन 2 , 48 बाइट्स

एक अनाम फ़ंक्शन जो परिणाम देता है। -1 बाइट एक्सनोर के लिए धन्यवाद।

lambda l:l.sort()or(l[len(l)/2]+l[~len(l)/2])/2.

पहला चरण स्पष्ट रूप से सरणी को सॉर्ट करना है, का उपयोग करना l.sort()। हालांकि, हम केवल एक लंबोदर में एक बयान दे सकते हैं, इसलिए हम इस तथ्य का उपयोग करते हैं कि क्रमबद्ध फ़ंक्शन पायथन में - जैसा कि मिथ्या है, यह Noneजोड़कर रिटर्न orकरता Noneहै, यह इसे मूल्यांकन और बयान के अगले भाग को वापस करने के लिए कहता है।

अब हमारे पास क्रमबद्ध सूची है, हमें या तो मध्य, या मध्य दो, मानों को खोजना होगा।

लंबाई की समता की जांच करने के लिए एक सशर्त का उपयोग करना बहुत अधिक क्रियात्मक होगा, इसलिए इसके बजाय हम अनुक्रमित len(l)/2और ~len(l)/2:

• पहली मंजिल है (लंबाई / 2) , जो मध्य तत्व को मिलती है यदि लंबाई विषम है, या केंद्रीय जोड़ी में बाईं वस्तु यदि लंबाई भी है।
• दूसरा सूची लंबाई का द्विआधारी व्युत्क्रम है, जिसका मूल्यांकन -1 - मंजिल (लंबाई / 2) है । पायथन के नकारात्मक अनुक्रमण के कारण, यह अनिवार्य रूप से पहले सूचकांक के समान है, लेकिन सरणी के अंत से पीछे की ओर है।

यदि सूची विषम लंबाई की है, तो ये सूचकांक समान मान को इंगित करेंगे। यदि यह और भी लंबा है, तो वे केंद्रीय दो वस्तुओं की ओर इशारा करेंगे।

अब जब हमारे पास ये दो सूचकांक हैं, तो हम सूची में इन मूल्यों को पाते हैं, उन्हें जोड़ते हैं, और उन्हें 2 से विभाजित करते हैं। अनुगामी दशमलव स्थान /2.यह सुनिश्चित करता है कि यह पूर्णांक विभाजन के बजाय फ्लोट डिवीजन है।

परिणाम स्पष्ट रूप से वापस आ गया है, क्योंकि यह एक लंबोदर फ़ंक्शन है।

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

Comments

ऐसा लगता है कि दोहराव के बावजूद एक lambda l:l.sort()or(l[len(l)/2]+l[~len(l)/2])/2.

— लंबोदर

@xnor धन्यवाद! जब मैंने कोशिश की, तो मैंने गलती से गिनती की f=, यह सोचकर कि यह 1 बाइट लंबी थी।

— FlipTack

Answer 2

पायथन 3 - 31 30 बाइट्स

@Dennis के लिए एक बाइट धन्यवाद बचा लिया!

मैं एक बेसिन उत्तर पर योजना नहीं बना रहा था, लेकिन मैंने इस मॉड्यूल को पाया और सोचा कि यह वास्तव में अच्छा क्यूज़ था मुझे पता नहीं था कि यह अस्तित्व में था।

from statistics import*;median

इसे यहाँ ऑनलाइन आज़माएँ ।

Comments

from statistics import*;medianएक बाइट बचाता है।

— डेनिस

@ डेनिस ओह कूल। क्या वह हमेशा छोटा है?

— माल्टसेन

यह हमेशा का उपयोग कर धड़कता है __import__, लेकिन import math;math.logहरा देंगे from math import*;log।

— डेनिस

Answer 3

दरअसल , 1 बाइट

║

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

Comments

नौकरी के लिए सही उपकरण।

— मेगो

Answer 4

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

L‘HịṢµ÷LS

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

व्याख्या

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

L          Get the length of the input.
 ‘         Increment it.
  H        Halve it. This gives us the index of the median for an odd-length list
           (Jelly uses 1-based indexing), and a half-integer between the two indices
           we need to average for even-length lists.
   ịṢ      Use this as an index into the sorted input. As explained above this will
           either give us the median (in case of an odd-length list) or a pair of
           values we'll now need to average.
     µ     Starts a monadic chain which is then applied to this median or pair...
      ÷L     Divide by the length. L treats atomic values like singleton lists.
        S    Sum. This also treats atomic values like singleton lists. Hence this
             monadic chain leaves a single value unchanged but will return the
             mean of a pair.

Comments

बेशक, Æṁअब काम करेगा

— caird coinheringaahing

Answer 5

ब्रेन-फ्लैक , 914 + 1 = 915 बाइट्स

([]){({}[()]<(([])<{({}[()]<([([({}<(({})<>)<>>)<><({}<>)>]{}<(())>)](<>)){({}())<>}{}({}<><{}{}>){{}<>(<({}<({}<>)<>>)<>({}<>)>)}{}({}<>)<>>)}{}<>{}>[()]){({}[()]<({}<>)<>>)}{}<>>)}{}([]<(()())>(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{}<(())>){((<{}{}([[]]()){({}()()<{}>)}{}(({}){}<([]){{}{}([])}{}>)>))}{}{(<{}([[]]()()){({}()()<{}>)}{}({}{}<([]){{}{}([])}{}>)>)}{}([(({}<((((((()()()){}){}){}()){})[()()()])>)<(())>)](<>)){({}())<>}{}<>{}{}<>(({})){{}{}<>(<(())>)}{}(({}<>)<{(<{}([{}])>)}{}{(({})<((()()()()()){})>)({}(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{})({}<({}<>)<>>((((()()()){}){}){}){})((()()()()()){})<>({}<>)(()()){({}[()]<([([({})](<()>))](<>())){({}())<>}{}<>{}{}<>(({})){{}{}<>(<(())>)}{}(({})<>)<>{(<{}([{}])>)}{}({}<>)<>({}<><({}<>)>)>)}{}({}(<>))<>([()]{()<(({})){({}[()])<>}{}>}{}<><{}{}>)<>(({}{}[(())])){{}{}(((<{}>)))}{}{}{(<{}<>([{}])><>)}{}<>}{}>){(<{}(((((()()()()())){}{})){}{})>)}{}

आवश्यक है -Aचलाने के लिए झंडा।

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

व्याख्या

इस एल्गोरिथ्म की रीढ़ एक बुलबुला प्रकार है जिसे मैंने कुछ समय पहले लिखा था।

([]){({}[()]<(([])<{({}[()]<([([({}<(({})<>)<>>)<><({}<>)>]{}<(())>)](<>)){({}())<>}{}({}<><{}{}>){{}<>(<({}<({}<>)<>>)<>({}<>)>)}{}({}<>)<>>)}{}<>{}>[()]){({}[()]<({}<>)<>>)}{}<>>)}{}

मुझे याद नहीं है कि यह कैसे काम करता है इसलिए मुझसे मत पूछो। लेकिन मुझे पता है कि यह स्टैक को सॉर्ट करता है और यहां तक ​​कि नकारात्मक के लिए भी काम करता है

सब कुछ हल हो जाने के बाद, मैं 2 बार के मंझले को निम्न चंक से ढूंढता हूं

([]<(()())>(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{}<(())>)  #Stack height modulo 2
{((<{}{}          #If odd
 ([[]]())         #Push negative stack height +1
 {                #Until zero 
  ({}()()<{}>)    #add 2 to the stack height and pop one
 }{}              #Get rid of garbage
 (({}){}<         #Pickup and double the top value
 ([]){{}{}([])}{} #Remove everything on the stack
 >)               #Put it back down
>))}{}            #End if
{(<{}                     #If even
  ([[]]()())              #Push -sh + 2
  {({}()()<{}>)}{}        #Remove one value for every 2 in that value
  ({}{}<([]){{}{}([])}{}>)#Add the top two and remove everything under them
>)}{}                     #End if

अब जो कुछ बचा है उसे ASCII में बदलना है

([(({}<((((((()()()){}){}){}()){})[()()()])>)<(())>)](<>)){({}())<>}{}<>{}{}<>(({})){{}{}<>(<(())>)}{}(({}<>)<
{(<{}([{}])>)}{}  #Absolute value (put "/2" beneath everything)

{                 #Until the residue is zero 
(({})<            #|Convert to base 10
((()()()()()){})  #|
>)                #|...
({}(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{})
({}<({}<>)<>>((((()()()){}){}){}){})((()()()()()){})<>({}<>)
                  #|
(()()){({}[()]<([([({})](<()>))](<>())){({}())<>}{}<>{}{}<>(({})){{}{}<>(<(())>)}{}(({})<>)<>{(<{}([{}])>)}{}({}<>)<>({}<><({}<>)>)>)}{}({}(<>))<>([()]{()<(({})){({}[()])<>}{}>}{}<><{}{}>)<>(({}{}[(())])){{}{}(((<{}>)))}{}{}{(<{}<>([{}])><>)}{}<>
}{}               #|
>)
{(<{}(((((()()()()())){}{})){}{})>)}{}  #If it was negative put a minus sign

Answer 6

आर, 6 बाइट्स

median

आश्चर्य नहीं कि R, एक सांख्यिकीय प्रोग्रामिंग भाषा है, जिसमें यह अंतर्निहित है।

Comments

Rपिटाई जेली: D: D: D

— JAD

Answer 7

MATL , 4 बाइट्स

.5Xq

यह 0.5-मात्रात्मक पाता है, जो औसत दर्जे का है।

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

Comments

मैं बस यह पता लगाने के लिए था!

— दोष

आह नहीं, मेरा मतलब है कि मैं समझ रहा था कि यह MATL = में कैसे करना है) (लेकिन मेरे पास 5 बाइट का घोल था, इसलिए हाँ ...)

— दोष

@flawr इसे तब पोस्ट करें! यह निश्चित रूप से मेरी तुलना में अधिक दिलचस्प होगा

— लुइस मेंडो

नहीं, यह आपके सामने सिर्फ एक के साथ एक ही था :)

— निर्दोष

@flawr वही iजो आपने निहित करने का सुझाव दिया था? :-P

— लुइस मेंडो

Answer 8

पायथ - 11 बाइट्स

मध्य की वस्तु के औसत को पीछे और आगे दोनों ओर ले जाता है।

.O@R/lQ2_BS

टेस्ट सूट ।

Answer 9

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

@(x)mean(([1;1]*sort(x))(end/2+[0 1]))

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

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

व्याख्या

            sort(x)                 % Sort input x, of length k
      [1;1]*                        % Matrix-multiply by column vector of two ones
                                    % This vertically concatenates the sort(x) with 
                                    % itself. In column-major order, this effectively 
                                    % repeats each entry of sort(x)
     (             )(end/2+[0 1])   % Select the entry at position end/2 and the next.
                                    % Entries are indexed in column-major order. Since
                                    % the array has 2*k elements, this picks the k-th 
                                    % and (k+1)-th. Because entries were repeated, for
                                    % odd k this takes the original (k+1)/2-th entry
                                    % (1-based indexing) twice. For even k this takes
                                    % the original (k/2)-th and (k/2+1)-th entries
mean(                            )  % Mean of the two selected entries

Comments

उह ... " bsxfun" और mean:-) का चतुर उपयोग

— स्टीवी ग्रिफिन

Answer 10

जावास्क्रिप्ट, 57 52 बाइट्स

v=>(v.sort((a,b)=>a-b)[(x=v.length)>>1]+v[--x>>1])/2

सरणी को संख्यात्मक रूप से क्रमबद्ध करें। यदि सरणी एक समान लंबाई है, तो 2 मध्य संख्या खोजें और उन्हें औसत करें। यदि सरणी विषम है, तो मध्य संख्या को दो बार ढूंढें और 2 से विभाजित करें।

Comments

मैंने पाया है कि Array.sort()दशमलव के साथ ठीक से काम नहीं करता है

— TrojanByAccident

यदि आप एक छँटाई समारोह में पास करते हैं जैसा कि मैंने किया था। यदि आप Array.sort () को बिना मापदंडों के कहते हैं, तो यह एक अल्फाबेटिक प्रकार का उपयोग करता है।

— ग्रैक्स 32

दिलचस्प। नहीं पता था कि

— TrojanByAccident

आप sort()सीधे वापसी के मूल्य का उपयोग करके और tपरिवर्तनशील से छुटकारा पाकर कुछ बाइट्स बचा सकते हैं :v=>(v.sort((a,b)=>a-b)[(x=v.length)>>1]+v[--x>>1])/2

— अरनौलड

ऐसा नहीं है कि आपको इसके लिए आवश्यक रूप से सही होना चाहिए, लेकिन अगर x>=2**31, यह विफल हो जाएगा। >>एक साइन-प्रोपेगेटिंग राइट शिफ्ट है , जिसका अर्थ है कि जब संख्या को 32 बिट पूर्णांक के रूप में व्याख्या की जाती है, यदि एमएसबी सेट है, तो यह सेट रहता है, जिसके परिणामस्वरूप परिणाम नकारात्मक होता है 2**32>x>=2**31। के लिए x>=2**32, यह सिर्फ पैदावार 0।

— पैट्रिक रॉबर्ट्स

Answer 11

मतलाब / ऑक्टेव, 6 बाइट्स

एक उबाऊ में निर्मित:

median

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

Comments

मैं MATLAB / ऑक्टेव में अनाम कार्यों के नियमों को भूल जाता हूं, क्या यह होना चाहिए @median?

— ग्यूसेप

@Giuseppe मुझे नहीं पता कि वर्तमान में निर्मित कार्यों को स्कोर करने का तरीका क्या है।

— दोष

Answer 12

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

Median

जैसे ही मैंने Mmmtca का पता लगाया , मैं इसमें एक समाधान पोस्ट कर रहा हूं।

Comments

Mthmtca 0.1 / 10.1.0.0 में, कोड बाइट्स CBC8( ËÈ) होगा। हालाँकि, जब तक मैं एक और पैच नहीं लगाता, फ़ंक्शन-कॉलिंग की धारणा पीपीसीजी के मानकों को पूरा नहीं कर सकती है।

— लेजियन मम्मल 978

Answer 13

पर्ल 6 , 31 बाइट्स

*.sort[{($/=$_/2),$/-.5}].sum/2

कोशिश करो

विस्तारित:

*\     # WhateverCode lambda ( this is the parameter )

.sort\ # sort it

[{     # index into the sorted list using a code ref to calculate the positions

  (
    $/ = $_ / 2 # the count of elements divided by 2 stored in ｢$/｣
  ),            # that was the first index

  $/ - .5       # subtract 1/2 to get the second index

                # indexing operations round down to nearest Int
                # so both are effectively the same index if given
                # an odd length array

}]\

.sum / 2        # get the average of the two values

Comments

24 बाइट्स

— Jo King

Answer 14

एपीएल (डायलॉग यूनिकोड) , 14 बाइट्स

≢⊃2+/2/⊂∘⍋⌷÷∘2

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

यह एक ट्रेन है। मूल dfn था {(2+/2/⍵[⍋⍵])[≢⍵]÷2}।

ट्रेन को इस प्रकार संरचित किया गया है

┌─┼───┐
≢ ⊃ ┌─┼───┐
    2 / ┌─┼───┐
    ┌─┘ 2 / ┌─┼─┐
    +       ∘ ⌷ ∘
           ┌┴┐ ┌┴┐
           ⊂ ⍋ ÷ 2

⊢ सही तर्क को दर्शाता है।

⌷ सूची

• ⊂∘⍋जिन सूचकांकों को क्रमबद्ध किए जाने के ⊢परिणामों में अनुक्रमित किया गया है⊢

• ÷∘2⊢2 से विभाजित किया गया

2/इसे दो बार दोहराएं, ऐसा 1 5 7 8हो जाता है1 1 5 5 7 7 8 8

2+/ जोड़ीदार राशि लीजिए, यह बन जाता है (1+1)(1+5)(5+5)(5+7)(7+7)(7+8)(8+8)

⊃ इस पिक से

• ≢ की लंबाई के बराबर सूचकांक के साथ तत्व ⊢

पिछले समाधान

{.5×+/(⍵[⍋⍵])[(⌈,⌊).5×1+≢⍵]}
{+/(2/⍵[⍋⍵]÷2)[0 1+≢⍵]}
{+/¯2↑(1-≢⍵)↓2/⍵[⍋⍵]÷2}
{(2+/2/⍵[⍋⍵])[≢⍵]÷2}
{(≢⍵)⊃2+/2/⍵[⍋⍵]÷2}
≢⊃2+/2/2÷⍨⊂∘⍋⌷⊢
≢⊃2+/2/⊂∘⍋⌷÷∘2

Answer 15

आम लिस्प, 89

(lambda(s &aux(m(1-(length s)))(s(sort s'<)))(/(+(nth(floor m 2)s)(nth(ceiling m 2)s))2))

मैं स्थिति में तत्वों के माध्य की गणना करता हूं (floor middle)और (ceiling middle), middleसॉर्ट की गई सूची के मध्य तत्व के लिए शून्य-आधारित सूचकांक कहां है। यह संभव है middleकी तरह, एक पूरी संख्या होने के लिए 1इस तरह के रूप आकार 3 की एक इनपुट सूची के लिए (10 20 30), या तत्वों, जैसे की एक और भी संख्या के साथ सूची के लिए एक अंश 3/2के लिए (10 20 30 40)। दोनों ही मामलों में, हम अपेक्षित औसत मूल्य की गणना करते हैं।

(lambda (list &aux
             (m (1-(length list)))
             (list (sort list #'<)))
  (/ (+ (nth (floor m 2) list)
        (nth (ceiling m 2) list))
     2))

Answer 16

विम, 62 बाइट्स

मैंने मूल रूप से अंत तक केवल पाठ हेरफेर का उपयोग करके वी में ऐसा किया था, लेकिन [एक्स] और [एक्स, वाई] को संभालने से निराश हो गया, इसलिए यहां आसान संस्करण है। वे एक ही लंबाई के बारे में हैं।

c$:let m=sort(")[(len(")-1)/2:len(")/2]
=(m[0]+m[-1])/2.0

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

Unprintables:

c$^O:let m=sort(^R")[(len(^R")-1)/2:len(^R")/2]
^R=(m[0]+m[-1])/2.0

माननीय उल्लेख:

• ^O आपको एक कमांड (लेट कमांड) के लिए इन्सर्ट मोड से बाहर ले जाता है।
• ^R" वह पाठ सम्मिलित किया गया था जो इस मामले में था (सूची में)

Answer 17

टीआई-बेसिक, 2 बाइट्स

median(Ans

बहुत सीधा है।

Comments

Ansअनुमति नहीं है I / O विधि ।

— मेगो

अपने लिंक और टिप्पणी confuses मुझे @Mego ... वोट के अनुसार, यह है की अनुमति दी। क्या मैं कुछ भूल रहा हूँ?

— पैट्रिक रॉबर्ट्स

@PatrickRoberts वास्तव में स्वीकार्यता के लिए सीमा के बारे में वर्तमान में कुछ बहस है। कई उपयोगकर्ता (स्वयं शामिल) नियम का पालन कर रहे हैं कि एक विधि को कम से कम +5 की आवश्यकता होती है और कम से कम दो बार डाउनवोट्स के रूप में कई upvotes, जो कि मूल रूप से उस पद में कहा गया नियम था (इसे हटा दिया गया है), और नियम का पालन किया जाता है मानक खामियों के लिए।

— Mego

जिसने भी मेरी अपनी पोस्ट से दो बार मेरी टिप्पणी निकाली वह कष्टप्रद है। चूंकि स्वीकार्यता पर कोई स्पष्ट रूप से स्वीकृत नियम नहीं है, इसलिए मुझे यहां समस्या दिखाई नहीं देती। आप एसओ पर मेरे जवाब देख सकते हैं कि यह कैसे एक कार्यक्रम के तर्क के रूप में उपयोग किया जाता है।

— टाइमटेक

@ मेगो +38 दो बार से ज्यादा -18

— टिमटेक

Answer 18

सी #, 126 बाइट्स

using System.Linq;float m(float[] a){var x=a.Length;return a.OrderBy(g=>g).Skip(x/2-(x%2==0?1:0)).Take(x%2==0?2:1).Average();}

बहुत सीधा है, यहाँ LINQ मानों को ऑर्डर करने के लिए, आधी सूची को छोड़ें, एक या दो मान लें जो सम / विषम पर निर्भर करता है और उन्हें औसत करता है।

Comments

आपको using System.Linq; अपनी बाइट गिनती में शामिल करने की आवश्यकता है , हालांकि आप कुछ बदलाव करके इसे रद्द कर सकते हैं। संकलन Func<float[], float>और 106 बाइट्स के लिए एक चर के लिए modulo के मूल्य को असाइन करने के लिए:using System.Linq;a=>{int x=a.Length,m=x%2<1?1:0;return a.OrderBy(g=>g).Skip(x/2-m).Take(++m).Average();};

— TheLethalCoder

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

— जेन्स

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

— TheLethalCoder

Answer 19

C ++ 112 बाइट्स

बाइट बचाने में मेरी मदद करने के लिए @ original.legin को धन्यवाद।

#include<vector>
#include<algorithm>
float a(float*b,int s){std::sort(b,b+s);return(b[s/2-(s&1^1)]+b[s/2])/2;}

उपयोग:

    int main()
    {
        int n = 4;
        float e[4] = {1,4,3,2};
        std::cout<<a(e,n); /// Prints 2.5

        n = 9;
        float e1[9] = {1,2,3,4,5,6,7,8,9};
        std::cout<<a(e1,n); /// Prints 5

        n = 13;
        float e2[13] = {1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,-5,100000,1.3,1.4};
        std::cout<<a(e2,n); /// Prints 1.5

        return 0;
    }

Comments

आप दो बाइट को बचाने के floatबजाय उपयोग कर सकते हैं double। इसके अलावा, जीसीसी पर, आप उपयोग कर सकते हैं #import<vector>और #import<algorithm>इसके बजाय #include। (ध्यान दें कि या तो आपको #includeया तो स्थान की आवश्यकता नहीं है #import)

— Steadybox

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

— वेड टायलर

यदि कोड उनके बिना संकलित नहीं होता है, तो बाइट गिनती में शामिल होना चाहिए।

— स्टेडीबॉक्स

Answer 20

जे , ₁₆ 14 बाइट्स

2%~#{2#/:~+\:~

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

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

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

2%~#{2#/:~+\:~
                Input: array of length n
       /:~      Sort ascending
           \:~  Sort descending
          +     Add the two element-wise
     2#         Duplicate each element
   #{           Take n-th element
2%~             Halve

---

पिछले जवाब

जे के साथ statsaddon, 18 बाइट्स

load'stats'
median

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

पुस्तकालय समारोह FTW।

medianकार्यान्वयन इस तरह दिखता है:

जे , 31 बाइट्स

-:@(+/)@((<.,>.)@(-:@<:@#){/:~)

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

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

-:@(+/)@((<.,>.)@(-:@<:@#){/:~)
         (<.,>.)@(-:@<:@#)       Find center indices:
                  -:@<:@#          Compute half of given array's length - 1
          <.,>.                    Form 2-element array of its floor and ceiling
                          {/:~   Extract elements at those indices from sorted array
-:@(+/)                          Sum and half

गोल्फ का एक सा यह देता है:

जे , 28 बाइट्स

2%~[:+/(<.,>.)@(-:@<:@#){/:~

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

Comments

अच्छी तरह से किया गया, मेरे एपीएल उत्तर का जे पोर्ट #{0,2+/\2#-:/:]करीब 15 बाइट्स (आदमी मुझे याद आती है ⎕io) पर होगा।

— १

Answer 21

जे, 19 बाइट्स

<.@-:@#{(/:-:@+\:)~

स्पष्टीकरण:

        (        )~   apply monadic argument twice to dyadic function 
         /:           /:~ = sort the list upwards
               \:     \:~ = sort the list downwards
           -:@+       half of sum of both lists, element-wise
<.@-:@#               floor of half of length of list
       {              get that element from the list of sums

Comments

आप कोष्ठक को हटाकर और ~प्रत्येक पर सीधे लागू करने के लिए एक बाइट बचा सकते हैं<.@-:@#{/:~-:@+\:~

— मील

Answer 22

जावास्क्रिप्ट, 273 बाइट्स

function m(l){a=(function(){i=l;o=[];while(i.length){p1=i[0];p2=0;for(a=0;a<i.length;a++)if(i[a]<p1){p1=i[a];p2=a}o.push(p1);i[p2]=i[i.length-1];i.pop()}return o})();return a.length%2==1?l[Math.round(l.length/2)-1]:(l[Math.round(l.length/2)-1]+l[Math.round(l.length/2)])/2}

Answer 23

जावा 7, 99 बाइट्स

golfed:

float m(Float[]a){java.util.Arrays.sort(a);int l=a.length;return l%2>0?a[l/2]:(a[l/2-1]+a[l/2])/2;}

Ungolfed:

float m(Float[] a)
{
    java.util.Arrays.sort(a);
    int l = a.length;
    return l % 2 > 0 ? a[l / 2] : (a[l / 2 - 1] + a[l / 2]) / 2;
}

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

Comments

मैं थोड़ा निराश हूँ यहां तक ​​कि जावा 7 में एक छोटा सा पर्याप्त छंटनी वाक्यविन्यास है जो en.wikipedia.org/wiki/… उप-रूप है

— जॉली जोकर

क्या आपको आयात की गणना करने की आवश्यकता नहीं है java.util.Arrays?

— FlipTack

वूप्स, ध्यान देने के लिए धन्यवाद। :)

— पीच

भविष्य से नमस्ते! लंबाई समता को संभालने के लिए पूर्णांक विभाजन ट्रंकेशन का उपयोग करके आप 14 बाइट्स बचा सकते हैं। मेरा जावा 8 उत्तर देखें ।

— जैकब

Answer 24

परी / जीपी - 37 39 बाइट्स

चलो एक मूल्यों से युक्त एक rowvector हो।

b=vecsort(a);n=#b+1;(b[n\2]+b[n-n\2])/2  \\ 39 byte              

n=1+#b=vecsort(a);(b[n\2]+b[n-n\2])/2    \\ obfuscated but only 37 byte

चूंकि Pari / GP संवादात्मक है, इसलिए परिणाम प्रदर्शित करने के लिए कोई अतिरिक्त आदेश की आवश्यकता नहीं है।

---

के लिए "की कोशिश यह ऑनलाइन" से पहले एक लाइन से जोड़ने और बाद जोड़ा जाता है। मुद्रित होने के लिए, माध्यिका-परिणाम को चर w में संग्रहीत किया जाता है

a=vector(8,r,random(999))           
n=1+#b=vecsort(a);w=(b[n\2]+b[n-n\2])/2      
print(a);print(b);print(w)       

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

Answer 25

जाप, 20 बाइट्स

n gV=0|½*Ul)+Ug~V)/2

इसे ऑनलाइन टेस्ट करें! जाप के पास वास्तव में इस चुनौती के लिए एक बहुत ही कम जवाब बनाने के लिए किसी भी बिल्ट-इन की आवश्यकता नहीं है ...

व्याख्या

n gV=0|½*Ul)+Ug~V)/2  // Implicit: U = input list
n                     // Sort U.
   V=0|½*Ul)          // Set variable V to floor(U.length / 2).
  g                   // Get the item at index V in U.
            +Ug~V     // Add to that the item at index -V - 1 in U.
                 )/2  // Divide by 2 to give the median.
                      // Implicit: output result of last expression

Answer 26

जावा 8, 71 बाइट्स

समानता है मज़ा! यहाँ से एक मेमना double[]है Double।

l->{java.util.Arrays.sort(l);int s=l.length;return(l[s/2]+l[--s/2])/2;}

यहां कुछ भी जटिल नहीं है। सरणी को क्रमबद्ध किया जाता है, और फिर मैं सरणी से दो संख्याओं का मतलब निकालता हूं। दो मामले हैं:

• यदि लंबाई समान है, तो पहली संख्या को सरणी के मध्य के ठीक आगे से लिया जाता है, और दूसरा नंबर पूर्णांक विभाजन से पहले की स्थिति से लिया जाता है। इन नंबरों का मतलब इनपुट का माध्यिका है।
• यदि लंबाई विषम है, sऔर s-1दोनों मध्य तत्व के सूचकांक में विभाजित हैं। संख्या को स्वयं में जोड़ा जाता है और परिणाम को दो से विभाजित किया जाता है, मूल मूल्य की उपज।

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

Answer 27

स्माइलबासिक, 45 बाइट्स

DEF M A
L=LEN(A)/2SORT A?(A[L-.5]+A[L])/2
END

मंजिल (लंबाई / 2) और फर्श (लंबाई / 2-0.5) पर तत्वों का औसत बहुत सरल हो जाता है, लेकिन मैं चीजों को घुमाकर 1 बाइट बचाने में सक्षम था:

DEF M A
SORT A    <- extra line break
L=LEN(A)/2?(A[L-.5]+A[L])/2
END

Answer 28

भूसी , 10 बाइट्स

½ΣF~e→←½OD

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

व्याख्या

$[a_1 \dots a_N]$$[a_1 \; a_1 \dots a_N \; a_N]$

½ΣF~e→←½OD  -- example input: [2,3,4,1]
         D  -- duplicate: [2,3,4,1,2,3,4,1]
        O   -- sort: [1,1,2,2,3,3,4,4]
       ½    -- halve: [[1,1,2,2],[3,3,4,4]]
  F         -- fold the following
   ~        -- | compose the arguments ..
     →      -- | | last element: 2
      ←     -- | | first element: 3
    e       -- | .. and create list: [2,3]
            -- : [2,3]
 Σ          -- sum: 5
½           -- halve: 5/2

_{दुर्भाग्य से ½सूचियों के लिए प्रकार है [a] -> [[a]]और नहीं [a] -> ([a],[a])है जो की अनुमति नहीं है F~+→←के बाद से foldl1की जरूरत है प्रकार की एक समारोह a -> a -> aपहले तर्क के रूप में, मुझे इस्तेमाल करने के लिए मजबूर कर रहा e।}

Answer 29

आर के बिना का उपयोग कर medianनिर्मित, 51 बाइट्स

function(x,n=sum(x|1)+1)mean(sort(x)[n/2+0:1*n%%2])

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

Comments

function(x)mean(x,.5)

— एनएमसी

Answer 30

गोल्फस्क्रिप्ट , 27 25 20 17 बाइट्स

~..+$\,(>2<~+"/2"

स्टड पर पूर्णांक के एक सरणी के रूप में इनपुट लेता है। एक अनियंत्रित अंश के रूप में आउटपुट। इसे ऑनलाइन आज़माएं!

व्याख्या

$l$$l-1$$l$

~                  Evaluate input (converting string -> array)
 ..                Duplicate twice
   +               Concatenate two of the copies
    $              Sort the doubled array
     \,            Swap with the non-doubled array and get its length: l
       (           Decrement: l-1
        >          Array slice: all elements at index (l-1) and greater
         2<        Array slice: first two elements (originally at indices l-1 and l)
           ~       Dump array elements to stack
            +      Add
             "/2"  Push that string
                   Output all items on stack without separator

आउटपुट कुछ इस तरह होगा 10/2।